• 关于

    分门别类

    的搜索结果

回答

Re说说硬盘挂载的建议 我也期待这个问题的答案,让我能更高效的利用磁盘 ------------------------- Re说说硬盘挂载的建议 我的意思就是分门别类,系统盘放系统,数据盘放数据。做到心中有数,今后维护更方便

xpress 2019-12-02 03:14:58 0 浏览量 回答数 0

问题

邮箱被异地登陆,文件夹也没了

嗯嗯呢 2019-12-01 21:37:34 3317 浏览量 回答数 1

回答

提问:异常和流程控制 位置: 二.(二)异常处理 正例:用户注册的场景中,如果用户输入非法字符,或用户名称已存在,或用户输入密码过于简单,在程序上作出分门别类的判断,并提示给用户。 第3条正例中的注册案例,根据不同的注册异常给出不同的响应。 是否与第2条不要用异常做流程控制和条件控制和我理解的第1条可以通过预检查方式规避的异常不应该通过catch的方式来处理的思路冲突呢?不管是非法字符或用户名称已存在或输入密码过于简单都是可以通过预检查方式规避的异常。 以前没太仔细考虑异常处理的问题,都是自定义异常直接抛。前段时间修改以前的demo,原本是像示例这样把校验失败都算作异常,但在一些论坛中的讨论贴看到说这样是滥用异常,于是就修改成做预检查用返回值来控制参数和权限校验这部分,但改完还是说不出来这两种处理方式的好坏。 手册里所说的这两条内容,没理解到位,关于用异常还是用预检查返回值控制流程的问题比较纠结。希望各位老师能帮我解惑,谢谢

游客3uxgnkvkgaic4 2020-04-22 10:32:17 0 浏览量 回答数 0

阿里云试用中心,为您提供0门槛上云实践机会!

0元试用32+款产品,最高免费12个月!拨打95187-1,咨询专业上云建议!

回答

XML Schema命名空间作用:1、避免命名冲突,像Java中的package一样2、将不同作用的标签分门别类(像Spring中的tx命名空间针对事务类的标签,context命名空间针对组件的标签)代码解释:1、xmlns="http://www.springframework.org/schema/beans"声明xml文件默认的命名空间,表示未使用其他命名空间的所有标签的默认命名空间。2、xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"声明XML Schema 实例,声明后就可以使用 schemaLocation 属性了3、xmlns:aop="http://www.springframework.org/schema/aop"声明前缀为aop的命名空间,后面的URL用于标示命名空间的地址不会被解析器用于查找信息。其惟一的作用是赋予命名空间一个惟一的名称。当命名空间被定义在元素的开始标签中时,所有带有相同前缀的子元素都会与同一个命名空间相关联。4、xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd这个从命名可以看出个大概,指定Schema的位置这个属性必须结合命名空间使用。这个属性有两个值,第一个值表示需要使用的命名空间。第二个值表示供命名空间使用的 XML schema 的位置,此处的各个值可以在对应的jar包中的META-INF里面的spring.schemas文件中找到所以我们需要什么样的标签的时候,就引入什么样的命名空间和Schema 定义就可以了。

小旋风柴进 2019-12-02 01:56:21 0 浏览量 回答数 0

回答

XML Schema命名空间作用:1、避免命名冲突,像Java中的package一样2、将不同作用的标签分门别类(像Spring中的tx命名空间针对事务类的标签,context命名空间针对组件的标签)代码解释:1、xmlns="http://www.springframework.org/schema/beans"声明xml文件默认的命名空间,表示未使用其他命名空间的所有标签的默认命名空间。2、xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"声明XML Schema 实例,声明后就可以使用 schemaLocation 属性了3、xmlns:aop="http://www.springframework.org/schema/aop"声明前缀为aop的命名空间,后面的URL用于标示命名空间的地址不会被解析器用于查找信息。其惟一的作用是赋予命名空间一个惟一的名称。当命名空间被定义在元素的开始标签中时,所有带有相同前缀的子元素都会与同一个命名空间相关联。4、xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd这个从命名可以看出个大概,指定Schema的位置这个属性必须结合命名空间使用。这个属性有两个值,第一个值表示需要使用的命名空间。第二个值表示供命名空间使用的 XML schema 的位置,此处的各个值可以在对应的jar包中的META-INF里面的spring.schemas文件中找到所以我们需要什么样的标签的时候,就引入什么样的命名空间和Schema 定义就可以了。

蛮大人123 2019-12-02 02:09:22 0 浏览量 回答数 0

问题

生意参谋/生e经报表一键批量下载

大码哥 2019-12-01 20:58:59 4129 浏览量 回答数 1

问题

用h5ai做你的下载站点

我的中国 2019-12-01 21:43:05 2217 浏览量 回答数 0

回答

详细解答可以参考官方帮助文档通过Bucket.ListObjects来列出当前Bucket下的文件。主要的参数如下: 参数 说明 Delimiter 用于对Object名字进行分组的字符。所有名字包含指定的前缀且第一次出现delimiter字符之间的object作为一组元素CommonPrefixes Prefix 限定返回的object key必须以prefix作为前缀。注意使用prefix查询时,返回的key中仍会包含prefix MaxKeys 限定此次返回object的最大数,如果不设定,默认为100,max-keys取值不能大于1000 Marker 设定结果从marker之后按字母排序的第一个开始返回 提示: ListObjects的示例代码在sample/list_objects.go 使用默认参数获取存储空间的文件列表,默认返回100条Object import "fmt" import "github.com/aliyun/aliyun-oss-go-sdk/oss" client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret") if err != nil { // HandleError(err) } bucket, err := client.Bucket("my-bucket") if err != nil { // HandleError(err) } lsRes, err := bucket.ListObjects() if err != nil { // HandleError(err) } fmt.Println("Objects:", lsRes.Objects) 指定最大返回数量,最多不能超过1000条 lsRes, err := bucket.ListObjects(oss.MaxKeys(200)) if err != nil { // HandleError(err) } fmt.Println("Objects:", lsRes.Objects) 返回指定前缀的Object,默认最多返回100条 lsRes, err := bucket.ListObjects(oss.Prefix("my-object-")) if err != nil { // HandleError(err) } fmt.Println("Objects:", lsRes.Objects) 指定从某个Object(my-object-xx)后返回,默认最多100条 lsRes, err := bucket.ListObjects(oss.Marker("my-object-xx")) if err != nil { // HandleError(err) } fmt.Println("Objects:", lsRes.Objects) 分页获取所有Object,每次返回200条 marker := oss.Marker("") for { lsRes, err := bucket.ListObjects(oss.MaxKeys(200), marker) if err != nil { HandleError(err) } marker = oss.Marker(lsRes.NextMarker) fmt.Println("Objects:", lsRes.Objects) if !lsRes.IsTruncated { break } } 分页所有获取从特定Object后的所有的Object,每次返回50条 marker = oss.Marker("my-object-xx") for { lsRes, err := bucket.ListObjects(oss.MaxKeys(50), marker) if err != nil { // HandleError(err) } marker = oss.Marker(lsRes.NextMarker) fmt.Println("Objects:", lsRes.Objects) if !lsRes.IsTruncated { break } } 分页所有获取指定前缀为的Object,每次返回80个。 prefix := oss.Prefix("my-object-") marker := oss.Marker("") for { lsRes, err := bucket.ListObjects(oss.MaxKeys(80), marker, prefix) if err != nil { // HandleError(err) } prefix = oss.Prefix(lsRes.Prefix) marker = oss.Marker(lsRes.NextMarker) fmt.Println("Objects:", lsRes.Objects) if !lsRes.IsTruncated { break } } 模拟目录结构 OSS是基于对象的存储服务,没有目录的概念。存储在一个Bucket中所有文件都 是通过文件的key唯一标识,并没有层级的结构。这种结构可以让OSS的存储非常 高效,但是用户管理文件时希望能够像传统的文件系统一样把文件分门别类放到 不同的“目录”下面。通过OSS提供的“公共前缀”的功能,也可以很方便地模拟目录 结构。公共前缀的概念请参考 列出Object 。 假设Bucket中已有如下文件: foo/x foo/y foo/bar/a foo/bar/b foo/hello/C/1 foo/hello/C/2 通过ListObjects,列出指定目录下的文件和子目录: lsRes, err := bucket.ListObjects(oss.Prefix("foo/"), oss.Delimiter("/")) if err != nil { // HandleError(err) } fmt.Println("Objects:", lsRes.Objects,"SubDir:", lsRes.CommonPrefixes) 结果中lsRes.Objects为文件,包括foo/x、foo/y;lsRes.CommonPrefixes即子目录,包括foo/bar/、foo/hello/。

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

回答

详细解答可以参考官方帮助文档通过Bucket.ListObjects来列出当前Bucket下的文件。主要的参数如下: 参数 说明 Delimiter 用于对Object名字进行分组的字符。所有名字包含指定的前缀且第一次出现delimiter字符之间的object作为一组元素CommonPrefixes Prefix 限定返回的object key必须以prefix作为前缀。注意使用prefix查询时,返回的key中仍会包含prefix MaxKeys 限定此次返回object的最大数,如果不设定,默认为100,max-keys取值不能大于1000 Marker 设定结果从marker之后按字母排序的第一个开始返回 提示: ListObjects的示例代码在sample/list_objects.go 使用默认参数获取存储空间的文件列表,默认返回100条Object import "fmt" import "github.com/aliyun/aliyun-oss-go-sdk/oss" client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret") if err != nil { // HandleError(err) } bucket, err := client.Bucket("my-bucket") if err != nil { // HandleError(err) } lsRes, err := bucket.ListObjects() if err != nil { // HandleError(err) } fmt.Println("Objects:", lsRes.Objects) 指定最大返回数量,最多不能超过1000条 lsRes, err := bucket.ListObjects(oss.MaxKeys(200)) if err != nil { // HandleError(err) } fmt.Println("Objects:", lsRes.Objects) 返回指定前缀的Object,默认最多返回100条 lsRes, err := bucket.ListObjects(oss.Prefix("my-object-")) if err != nil { // HandleError(err) } fmt.Println("Objects:", lsRes.Objects) 指定从某个Object(my-object-xx)后返回,默认最多100条 lsRes, err := bucket.ListObjects(oss.Marker("my-object-xx")) if err != nil { // HandleError(err) } fmt.Println("Objects:", lsRes.Objects) 分页获取所有Object,每次返回200条 marker := oss.Marker("") for { lsRes, err := bucket.ListObjects(oss.MaxKeys(200), marker) if err != nil { HandleError(err) } marker = oss.Marker(lsRes.NextMarker) fmt.Println("Objects:", lsRes.Objects) if !lsRes.IsTruncated { break } } 分页所有获取从特定Object后的所有的Object,每次返回50条 marker = oss.Marker("my-object-xx") for { lsRes, err := bucket.ListObjects(oss.MaxKeys(50), marker) if err != nil { // HandleError(err) } marker = oss.Marker(lsRes.NextMarker) fmt.Println("Objects:", lsRes.Objects) if !lsRes.IsTruncated { break } } 分页所有获取指定前缀为的Object,每次返回80个。 prefix := oss.Prefix("my-object-") marker := oss.Marker("") for { lsRes, err := bucket.ListObjects(oss.MaxKeys(80), marker, prefix) if err != nil { // HandleError(err) } prefix = oss.Prefix(lsRes.Prefix) marker = oss.Marker(lsRes.NextMarker) fmt.Println("Objects:", lsRes.Objects) if !lsRes.IsTruncated { break } } 模拟目录结构 OSS是基于对象的存储服务,没有目录的概念。存储在一个Bucket中所有文件都 是通过文件的key唯一标识,并没有层级的结构。这种结构可以让OSS的存储非常 高效,但是用户管理文件时希望能够像传统的文件系统一样把文件分门别类放到 不同的“目录”下面。通过OSS提供的“公共前缀”的功能,也可以很方便地模拟目录 结构。公共前缀的概念请参考 列出Object 。 假设Bucket中已有如下文件: foo/x foo/y foo/bar/a foo/bar/b foo/hello/C/1 foo/hello/C/2 通过ListObjects,列出指定目录下的文件和子目录: lsRes, err := bucket.ListObjects(oss.Prefix("foo/"), oss.Delimiter("/")) if err != nil { // HandleError(err) } fmt.Println("Objects:", lsRes.Objects,"SubDir:", lsRes.CommonPrefixes) 结果中lsRes.Objects为文件,包括foo/x、foo/y;lsRes.CommonPrefixes即子目录,包括foo/bar/、foo/hello/。

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

问题

移动应用解决互联网提供商销售管理难题

lailaihui 2019-12-01 20:19:39 6585 浏览量 回答数 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: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

问题

JavaScript-SDK之如何实现管理文件(一)?

青衫无名 2019-12-01 21:44:26 973 浏览量 回答数 0

问题

Ruby-SDK之如何实现管理文件?

青衫无名 2019-12-01 21:46:37 1098 浏览量 回答数 0

回答

在我国,马克思主义理论作为学科的定位,在学科学术化的旗帜下一直被边缘化.尤其是马克思主义理论被规划为一级学科以后,还有一种观点仍然坚持认为,这只是出于政治上的需要.换言之,马克主义理论作为一级学科,只是一种工具理性,不具有学科建设定位的价值理性.那么,马克思主义理论学科的价值定位究竟决定于什么?这是一个亟待要厘清的论题. 一、马克思主义理论学科定位的价值因素 学科(discipline)应是一定科学领域或一门科学的分支,即学术的分支和知识的分门别类[1].马克思主义理论是人文社会科学门类的一个学术分支.人文社会科学门类都是由价值来主导的,不管其是否坦诚表明,或者秘而不宣,都离不开自己的价值目的,有的甚至是专门为一定的价值目的而设的. 人文社会科学的价值目的是人文社会科学学科定位的先导性因素.问题是,马克思主义学科的价值目的究竟是何以可能的?马克思主义理论学科是人文社会科学知识的一个分支,马克思主义理论学科价值既有人文社会科学的相同的价值目的,更有自己的价值特质.人们往往只注意其价值目的,而忽视其内在的价值特质.其实,价值目的只是一种外在的工具手段价值,其是否可能是由其独立于结果的内在价值决定的.在这里,我们不妨借用韦伯在《经济与社会》中的社会学的价值分析范式来解读这一概念.韦伯认为,资本主义何以可能在欧洲发展起来?就在于有一种为西方世界所有而在其他世界、地域所无的近代理性的资本主义发展的推动力.资本主义社会发展过程可以说就是资本主义的理性主义传统在欧洲的理性化(合理性)的过程.这种合理性主要可以分为价值合理性和目的合理性两种价值因素.价值合理性主要是新教伦理所包含推动资本主义发展的内在的精神价值.这是推动资本主义发展的“心原力”.而目的合理性则是理性主义传统在形式上的展开,它是近代资本主义的形式要件,比如合理化的法律和科层化官僚体制等.韦伯虽然区分在理性主义传统价值合理性和目的合理性,并论述了二者的密切联系,但是他并不为作为“心原力”的内在价值合理性使作为“形式要件”的外在价值成为可能.他甚至认为,目的手段合理性与价值合理性二者互不相容.他说:“从目的合乎理性的立场出发,价值合乎理性总是非理性的,而且它越是把行为以之为取向的价值上升为绝对价值,它就越是非理性的.”[2]由于近代资本主义技术理性的膨胀,工具理性反过来成为统治人类社会的怪物,所以,与其说韦伯论述的是工具理性与价值理性的相互冲突,还不如说他论述了工具理性与价值理性在资本主义技术统治至上条件下的人与物的手段之间的相互异化.但是,马克斯·韦伯价值理性的论述,其价值意义其实不在这里,希尔贝克说:韦伯对行动理想类型的论述,其意义在于“使得更准确界定了欧洲文化发展过程中的合理化和现代化的涵义成为可能”[3].这就是说,西方现代化的目的价值之所以成为可能是由欧洲文化与其他地域不同的内在价值决定的.这一点是合理的,即西方现代化的外在的目的手段价值之所以成为可能,是由于其西方文化的内在价值特质决定的.显然,文化不能是现代化的决定性因素,但它说明了传统文化内在价值与现代化的目的手段的外在价值的相互关系.基督教新教伦理之所以能转换为资本主义精神,是因为经过马丁·路德、加尔文的宗教改革,使新教的天职观具有发财致富的资本主义价值目的等内在价值特质[4]. 历史事实雄辩地证明了这一点.在公元325年左右,基督教由民间宗教之所以上升罗马帝国的意识形态的国教,不是罗马帝国的工具需要决定的,主要还是由于早期民间基督教本身的价值特质决定的.因为起源于早期民间基督教的“爱”的宽容与和谐向善,可以化解外族日耳曼征服者与被征服者罗马本族之间的矛盾冲突并使其融合的价值特质,从而使其成为一种意识形态.在中国古代,诸子纷呈,为什么会废黜百家,独尊儒术?是因为儒学本身具有“屈民而伸君,屈君而伸天”的内在价值(董仲舒《春秋繁露·玉环》).尽管儒学“屈君”价值目的最后成为泡影,但是“屈民”却成为了世世代代封建帝王的价值主旨.马克思主义理论本质上与基督教、儒学完全不同,但以上历史事实说明,任何一种思想体系之所以成为一种意识形态,都不是因为外在的工具价值需要决定的.一种知识体系成为一种意识形态,本质上决定于这种知识体系是否具有那个时代、社会发展的内在价值特质. 知识、教育的目的手段价值更是如此,外在的目的价值是由内在价值决定的.托马斯·马格奈尔认为,教育都蕴涵了价值因素,它包括工具价值和内在价值.内在价值就是指教育本身的价值,而工具价值“是一种达成某种目的的手段价值”[5].比如“学习”可以区分为,为了达到一定目标获得某种成就的学习和作为内在价值的独立学习,如思考能力、创造能力的素质培养的内在价值的学习.在他看来,二者相比,内在价值才是最根本的.如果内在价值丧失了,那就失去了学习的最高价值.托马斯·马格奈尔的看法具有一定的合理性.价值虽然是关系范畴,但价值本身说明客体具有满足主体需要的客观属性.这种客观属性就是客体满足主体需要的内在价值.而外在的工具价值,只是这种内在价值的形式要件.内在价值才是最根本的,它是使工具价值成为可能的因素. 马克思主义理论学科的定位不是由外在的意识形态的工具价值决定的,马克思主义理论的学科定位本质上决定于马克思主义理论自身的内在价值特质.马克思主义理论学科价值可以区分为内在价值和外在价值.内在价值,是指马克思主义理论本身所具有的与其他知识体系不同的能够满足时代和社会发展的一定需要的内在价值特质.外在价值,也可以称之为目的———手段工具价值,它是指马克思主义理论所具有的能够满足时代和社会发展的一定需要的效用,即马克思主义同其他人文社会科学一样,如哲学、伦理学、宗教神学、政治学、法学等,可以成为一个阶级的意识形态.但马克思主义学科的价值目的是否可能,首先是决定于马克思主义理论具有当代社会所需要的内在价值特质,而决非像有一种观点所说的那样,是因为政治的工具需要. 二、马克思主义理论的价值特质的社会意义 价值观虽然是一种精神现象,但不是凭空想象的产物,它必须建立在一定的现实基础之上.“价值的本质是客体主体化,是客体对主体本质力量的效应”[6].马克思主义理论之所以具有目的或工具价值,在于马克思主义理论本身具有满足当代社会目的需要的客观属性.马克思主义理论科学定位之所以可能,是因为马克思主义理论具有能够满足现代社会所需要的内在的价值特质. 1.马克思主义理论立足点代表了人类社会进步最基本的价值立场.狄尔泰认为,人文科学主张由三个层次构成:事实、命题、价值判断和规则.他说:“当人文科学发展起来时,除了它的知识以外,它还会包括一种与价值、理想、规则和塑造未来的目标相联系的价值判断和命令系统的意义.”[7]韦伯认为,社会科学就是以文化事件为对象的科学.文化事件的规定包含着两种基本的要素,这就是价值和意义.虽然如此,但他否定价值观念的客观性,认为价值观念是“主观的”[8].作为人文社会科学的马克思主义理论,它包含的基本要素,就是使其内在价值成为可能的基本的价值立场.马克思主义价值基本立足点不是市民社会,而是人类社会和社会化的人类.马克思主义公开表明自己的理论就是为全世界无产阶级的自由和解放服务的价值立场.马克思主义理论具有有史以来任何人文社会学科不同的价值特质. 在人类社会发展中,中国传统的道德律:“己所不欲,勿施于人”,被当代世界普遍认为为道德的金律.这里揭示人类社会一般的共同价值立场和伦理共识,那就是任何强者把自己不欲求的强加于人,都是不道德的.它表达了弱者的道德诉求和社会对强者的伦理禁约.所以,有些思想家专门以强者和弱者为价值标准来看人们的价值立场和人文社会科学的价值目的.但是,在人文社会科学发展史上,如果按一般的伦理共识,在古代,除开早期的犹太教、中国墨家的价值倾向和现代的马克思主义的价值立足点是弱者外,其他各种思想流派的价值立足点都可以说是强者.我国早期的资产阶级启蒙思想家梁启超就是这样来区分当时的社会思潮的.他说:“今之德国有最占势力之两大思想,一曰麦咯士(马克思—引者注)之社会主义,一曰尼至埃(尼采—引者注)之个人主义.麦咯士谓今日社会之弊在多数之弱者为少数之强者所压伏,尼至埃谓今日社会之弊在少数之优者为多数劣者所嵌制.”(梁启超《进化论革命者颉德之学说》,《新民丛报》第18期)梁启超的论述说明了不同的人文社会科学的确有不同的价值立场.当然,马克思主义与尼采所代表的资产主义理论分歧远不只这些.事实上,马克思批判资本主义,重估人文社会科学的价值,是因为以往的人文社会科学理论,尤其是资本主义的人文社会科学理论,都是为那些在私有制社会占统治地位的剥削阶级统治无产阶级和劳动者价值目的服务的理论.尼采“要重估一切价值”,是指要重估基督教的道德价值,建立资产阶级的强者的价值.因为,在他看来,以往的人文社会科学理论都是基督教为弱者或劳动者的价值目的服务的理论.可见,马克思主义理论中的弱者和尼采哲学的强者,都不是一般意义上的弱者和强者.马克思主义理论的价值立场就是要为现代先进生产力的代表———无产阶级的解放服务.江泽民从马克思主义理论价值立足点出发,阐述的“三个代表的重要思想”,实质上阐述了马克思主义的基本价值立场. 2.马克思主义的基本原理构建了当代社会基本的价值原则.马克思主义基本原理是一个以马克思主义的世界观、人生观和价值观为理论基础的有机整体.马克思主义的世界观、人生观和价值观的相互统一为当代社会构建了基本价值原则.这些价值原则主要有:事实与价值、生活世界与意义世界相统一,历史决定论与历史价值选择论相统一的原则,人的自我价值与社会价值相统一的价值原则等等. 首先,事实与价值的关系问题是构建社会主义社会价值原则一个重大的基本问题.实践的唯物主义是马克思主义基本原理的世界观基础.实践的唯物主义对于社会主义目的价值原则的建构具有重大的理论和实际意义.一些思想家把事实与价值、“是”与“应当”的关系绝对对立起来,如休谟就认为善的价值既不能建立在对象的关系上,也不能被理性所认识,从“是”(事实)推不出“应当”(价值)[9].马克思主义把存在论与价值论统一起来,认为价值只能是事实的价值,离开了事实的价值就是一个光光突突的概念.因为,对事实、对象,不能只是从客体的或直观的形式去理解,而应把它们当作感性的人的活动,当作实践去理解,从主体方面去理解[10].价值的本质是客体主体化,是客体对主体本质力量的效应.事实只是主体本质力量的对象化,而不是与主体无关的事物.事实与价值都必须从主体方面去理解才是可能的.价值以事实为基础,“应当”以“是”为前提,以“是”为联系词的事实判断,本身就包含了以“应当”为联系词的价值判断.马克思主义关于事实与价值关系的基本原理,为社会主义正确处理生活世界与意义世界的辩证关系,物质文明与精神文明、政治文明之间的辩证关系,社会主义现代化实践运动与共产主义理想终极关怀的辩证关系等等提供了基本的价值原则. 其次,马克思主义历史决定论与历史价值选择论相统一的原理,为正确认识社会主义的本质提供了价值标准.恩格斯在《反杜林论》中论述了马克思主义基本原理的内在联系.他认为,这个整体的核心内容是现代社会主义.马克思主义哲学揭示了人类社会从资本主义向社会主义发展的必然性.马克思主义的政治经济学揭示的是资本主义向社会主义发展的途径和力量.所以,从马克思主义基本原理整体性来理解,马克思主义实质上是关于社会发展规律、途径和实现的手段与力量的基本理论.这些理论为当代社会构建了基本价值原则.但是,社会主义的本质究竟是什么?在我国社会主义建设过程中,一种突出的倾向就是唯心地以价值标准代替历史标准,以人为的生产关系进步的价值评价取代关于社会进步和发展的历史标准.历史的进步是人的价值的选择结果.马克思说:“历史不过是追求着自己目的的人的活动而已.”[11]但是,历史是有规律的,历史的价值选择归根以历史的必然规律为前提,合目的性与和合规律性是相互统一的,离开历史的客观规律的选择就是唯心主义的意志决定论.邓小平以马克思主义基本原理为基础,把历史决定论和历史价值选择论结合起来,提出了“三个有利于”,为认识社会主义社会本质提供了价值标准. 最后,马克思主义人的价值基本原理是社会主义价值导向确立的基本出发点.不同的人的价值理论就有不同价值导向.西方近代资本主义以来,把社会看作是个人的简单相加,坚持以个人本位的个人主义的价值导向,否定人的社会价值.马克思主义认为,个人的自我价值和社会价值是相互统一的.他说:“全部人类历史的第一个前提无疑是有生命的个人的存在.”[10]现实的个人无疑是一切社会存在的前提.但是,现实的个人的存在又必须以物质资料生活的生产活动为前提.马克思说:生产“立即表现为双重关系:一方面是自然关系,另一方面是社会关系;社会关系的含义在这里是指许多个人的共同活动”[10].所以,马克思主义的现实的个人,不是指人的一种抽象本质.人的本质在其现实性上,它是一切社会关系的总和.由于社会关系是指许多个人的共同活动.所以,人的本质的自我实现必须以社会的实践活动为前提.个人与社会关系不是绝对对立的,而是一种互为前提的相辅相成的辩证关系.马克思主义这一基本原理为社会主义价值导向的选择和定位提供了理论前提.社会主义价值导向既要坚持集体主义为核心,又必须以每个人的自由的全面发展为前提. 3.马克思主义方法论为社会主义科学发展观提供了一般价值工具.唯物辩证法是马克思主义分析世界和社会的基本方法.唯物辩证法的总特征是联系和发展.唯物辩证法是建构社会主义科学发展观的一般价值分析工具.发展是一个系统工程,发展必须坚持以人为本,全面协调和处理好人与物、人与环境的发展关系.发展是一个过程,发展必须处理代内与代际之间的关系,从而实现可持续性发展.发展的中心是经济建设,发展的目标是推动人的全面发展. 总之,马克思主义理论学科定位首先是由于其本身具有优异理论品质的内在价值属性决定的,把马克思主义理论学科定位仅仅看作是意识形态的工具需要,而否定马克思主义理论自身的理性价值特质是片面的. 三、马克思主义理论学科定位的基本原则 马克思主义理论的内在的理性价值和外在工具价值是不可分割的.二者的关系问题既是一个学术问题,又是一个现实问题.正确处理马克思主义理论学科的学术性和现实性是马克思主义理论学科定位和存在与发展的一个十分重大的问题. 马克思主义理论是一门学术性和现实性很强的学科.其一,学术性是马克思主义理论科学性的突出表现.马克思主义的理论是科学.科学性决定了马克思主义的学术性.因为理论是理性的,但每一个论点和结论都必须源于科学事实.如果一种理论不是科学的,那么这种理论也就失去了它的学术意义与价值.马克思主义理论之所以是科学的,是因为马克思主义的每一个观点和基本结论都根据于大量的实证经验材料,都是他们对自然、人类社会历史的深刻研究的理论结晶.马克思主义哲学是科学,是因为它是自然、思维和社会知识的概括和总结.尤其是他的历史唯物主义,除开他对欧洲哲学和德国古典哲学的理论的批判和改造,就是他对资本主义政治、经济、文化等深刻研究和考察的理论创新.但马克思主义理论不是教条.如何与时俱进地把握马克思主义理论的精神实质,这就决定马克思主义理论研究的学术性.其二,现实性是马克思主义理论科学性的本质特征.恩格斯曾转引黑格尔的话说:“现实性在其展开过程中表明为必然性.”[12]可见,对现实性,不能只从客体方面去理解,而应从主体的实践方面来理解.在《德意志意识形态》中,马克思曾把自己的理论概括为“实践的唯物主义”.这里的实践的唯物主义,在哲学研究中,认为这就是马克思主义的哲学.这显然是一种误读.马克思说:“对于实践的唯物主义者即共产义者来说,全部问题都在于使现存世界革命化,实际地反对并改变现存的事物.”[10]既然实践的唯物主义者即共产主义者,那么,马克思主义的共产主义理论就是实践的唯物主义;既然现实性要从实践方面来理解,马克思主义理论就必须为社会主义革命和建设的实际服务,从而“使现存世界革命化,实际地反对并改变现存的事物”.其三,马克思主义是学术性和现实性辩证统一的理论.形而上学地把马克思主义的学术性和现实性对立起来,从而否定马克思主义学术性是十分错误的.学术性和现实性是相辅相成的.现实不等于现存的现象,现存现象中只有那些表明为本质的必然性的事物才是现实的.而现象总是显露于外,本质总是深藏于现象之内的东西.学术性就在于揭示和探索现实展开过程中事物表明为本质的必然性的内在联系.可见,学术性与现实性是不可分割的.马克思主义理论学术性和现实性的辩证统一,从而使马克思主义内在价值向外在工具价值的转化成为可能. 割裂马克思主义理论现实性和学术性关系倾向,可以从近代欧洲唯理论和经验论那里找到其最早的思想理论根源.随着近代分析科学的发展,学科的分门别类成为一个理论问题.在对待学科的学术性和现实性上,在近代随着经验论和唯理论的出现,实际上明显表现为两种学科悖论:即学科理性壁垒悖论和学科经验壁垒悖论.唯理论认为,任何知识都源于理性,理论理性、学术性与实际经验无关.问题是,任何学术都是有现实需要的学术,只是其学科的领域不同.实践证明,脱离实际经验的理论理性的学术是不存在的.这就是所谓的学科理性壁垒悖论.经验论认为,任何知识都是经验综合的结果,学术性与理论理性无关.经验论否定学术的学理性,但本身就是学术理论.这也是洛克陷入二重经验论悖论根源.问题是,任何学术本身都是理性的,而任何现实需要的学科又与理性无关,这就是所谓的学科经验壁垒悖论.康德看到了二者的矛盾,试图将理论理性和实践理性、学科的学术性和现实性整合在他的知识体系模式中.在知识范围内,知识不能离开经验和现实,实践的价值理性又必须脱离经验,只有在美的目的理性中二者的统一才有可能.这就要求大家都成为美学家.康德模式的尝试也是不成功的.马克思主义批判唯理论和经验论,批判和改造了德国的古典哲学、英国的古典政治经济学和空想社会主义创造的科学理论体系,从而把马克思主义科学性与革命性、学术性与现实性、理论与实践的关系辩证地统一起来.因此,马克思主义理论学科的具体定位,必须坚持三个基本原则. 1.坚持科学性与革命性相统一原则,与时俱进地把马克思主义理论建设成一门学理性较强的基础理论学科.马克思主义理论的科学性,决定了马克思主义理论是具有内在价值的学科.这种内在价值从而使马克思主义的外在的工具价值成为可能.科学性是马克思主义理论学科成为有生命的学科的基础,它是马克思主义理论学科价值理性根本源泉.没有科学性的学科就是没有生命和价值的伪科学.马克思主义的科学性能使马克思主义具有与时俱进的革命性和创造性的理论品质,也是马克思主义能够满足无产阶级目的工具价值需要,成为无产阶级革命和建设精神武器的前提.问题是,马克思主义的基础理论是什么? 马克思主义理论基础是哲学、政治经济学、政治学,还是社会学?但马克思主义并不等于哲学、政治经济学、政治学和社会学.那么,离开哲学、经济学和政治学的马克思主义理论还有什么呢?离开了这些学理性较强的基础学科,马克思主义理论无疑就会成为一个空壳.而事实是,这些学科早已从马克思主义理论中分离和独立出去,而把马克思主义哲学、政治经济学等归入马克思主义理论学科,也会造成马克思主义理论在学科门类中的相互交叉,界线不清.这就是说,马克思主义理论是一门既不能是马克思主义哲学、政治经济学和政治学等,又不能脱离马克思主义哲学、政治经济学和政治学等理论基础的学科.所以,马克思主义理论应该是以马克思主义哲学、政治经济学和政治学等为理论基础,并从总体上来研究它们的内在联系的基础理论的学科.从这个意义上说,马克思主义理论应该属于哲学门类的马克思主义理论的学科学,而不是定位于法学. 2.坚持学术性与现实性相统一原则,以学术性为动力实现马克思主义理论研究的综合创新.创新是马克思主义理论的灵魂.马克思主义既然是从总体上来研究马克思主义理论,那么,马克思主义理论的创新虽然离不开马克思主义哲学、政治经济学等各门子学科的创新,但马克思主义理论作为一门总体上对马克思主义理论研究的学科,主要区别于马克思主义哲学、政治经济学和政治学等个别学科门内的理论创新,是一种综合创新.这种创新对马克思主义理论学科如何把学术性和现实性结合起来提出了更高的要求.从马克思主义理论同马克思主义的学术性和现实性的关系看,现实性是马克思主义创新的源泉,学术性是创新的机制和动力.问题是,究竟是学术性重于现实性,还是现实性比学术性更重要?一般认为马克思主义的现实性比学术性更为重要,其实恰好相反,从主体方面来理解,学术性更加重要.因为对现实,不能直观地去理解,现实的必然性只有通过主体学术性的研究才能揭示出来.主体的学术性活动,本身就是一种理论的实践活动.这种实践当然不同于物质的实践活动.但是,在理论的研究和创新中,理论的发生源虽然来自现实,但是理论创新的动力是学术性.只有突出马克思义理论的学术性,才能实现马克思主义理论的综合创新,丰富马克思主义理论自身的价值内涵.综合创新首先需要综合研究,因而,国内外马克思主义原始文献综合收集、整理和研究则成为这个学科建设的百年大计,建议在马克思主义理论的二级学科中,增加一个马克思主义理论文献研究的二级学科. 3.坚持理论与实践相统一的原则,以实践为基础实现马克思主义理论学科的价值目的.马克思主义理论的价值目的最终要通过实践来实现.但是,从现在的二级学科设计来看,马克思主义理论的实践好像只是思想政治教育的实践,这样以来,马克思主义的工具价值的意义的确被意识形态化了.马克思主义是中国的主流意识形态,这是马克思主义理论教育学科设立的价值目的.但如果只是这样来理解马克思主义理论与实践的关系,显然是不恰当的.马克思主义理论的实践首先是马克思主义理论在社会主义革命和建设中的实践.因而,在马克思主义理论各个二级学科的研究方向设立中,是否应该考虑本学科在当代实践的研究.这样,各个二级学科理论的研究不仅有了自己学科的理论价值,而且也突现其理论的应用或工具价值.

liujae 2019-12-02 01:16:52 0 浏览量 回答数 0

回答

曾经因为看不懂数据结构和算法,而一度怀疑是自己太笨,实际上,很多人在第一次接触这门课时,都会有这种感觉,觉得数据结构和算法很抽象,晦涩难懂,宛如天书。正是这个原因,让很多初学者对这门课望而却步,希望以下分享能为初学者排忧解难。 我个人觉得,其实真正的原因是你没有找到好的学习方法,没有抓住学习的重点。实际上,数据结构和算法的东西并不多,常用的、基础的知识点更是屈指可数。只要掌握了正确的学习方法,学起来并没有看上去那么难,更不需要什么高智商、厚底子。 还记得大学里每次考前老师都要划重点吗?今天,我就给你划划我们这门课的重点,再告诉你一些我总结的学习小窍门。相信有了这些之后,你学起来就会有的放矢、事半功倍了。 什么是数据结构?什么是算法? 大部分数据结构和算法教材,在开篇都会给这两个概念下一个明确的定义。但是,这些定义都很抽象,对理解这两个概念并没有实质性的帮助,反倒会让你陷入死抠定义的误区。毕竟,我们现在学习,并不是为了考试,所以,概念背得再牢,不会用也就没什么用。 虽然我们说没必要深挖严格的定义,但是这并不等于不需要理解概念。下面我就从广义和狭义两个层面,来帮你理解数据结构与算法这两个概念。 从广义上讲,数据结构就是指一组数据的存储结构。算法就是操作数据的一组方法。 图书馆储藏书籍你肯定见过吧?为了方便查找,图书管理员一般会将书籍分门别类进行“存储”。按照一定规律编号,就是书籍这种“数据”的存储结构。 那我们如何来查找一本书呢?有很多种办法,你当然可以一本一本地找,也可以先根据书籍类别的编号,是人文,还是科学、计算机,来定位书架,然后再依次查找。笼统地说,这些查找方法都是算法。 从狭义上讲,是指某些著名的数据结构和算法,比如队列、栈、堆、二分查找、动态规划等。这些都是前人智慧的结晶,我们可以直接拿来用。我们要讲的这些经典数据结构和算法,都是前人从很多实际操作场景中抽象出来的,经过非常多的求证和检验,可以高效地帮助我们解决很多实际的开发问题。 那数据结构和算法有什么关系呢?为什么大部分书都把这两个东西放到一块儿来讲呢? 这是因为,数据结构和算法是相辅相成的。数据结构是为算法服务的,算法要作用在特定的数据结构之上。因此,我们无法孤立数据结构来讲算法,也无法孤立算法来讲数据结构。 比如,因为数组具有随机访问的特点,常用的二分查找算法需要用数组来存储数据。但如果我们选择链表这种数据结构,二分查找算法就无法工作了,因为链表并不支持随机访问。 数据结构是静态的,它只是组织数据的一种方式。如果不在它的基础上操作、构建算法,孤立存在的数据结构就是没用的。 现在你对数据结构与算法是不是有了比较清晰的理解了呢?有了这些储备,下面我们来看看,究竟该怎么学数据结构与算法。 看到数据结构和算法里的“算法”两个字,很多人就会联想到“数学”,觉得算法会涉及到很多深奥的数学知识。那我数学基础不是很好,学起来会不会很吃力啊? 数据结构和算法课程确实会涉及一些数学方面的推理、证明,尤其是在分析某个算法的时间、空间复杂度的时候,但是这个你完全不需要担心。 学习的重点在什么地方? 提到数据结构和算法,很多人就很头疼,因为这里面的内容实在是太多了。这里,我就帮你梳理一下,应该先学什么,后学什么。你可以对照看看,你属于哪个阶段,然后有针对地进行学习。 想要学习数据结构与算法,首先要掌握一个数据结构与算法中最重要的概念——复杂度分析。 这个概念究竟有多重要呢?可以这么说,它几乎占了数据结构和算法这门课的半壁江山,是数据结构和算法学习的精髓。 数据结构和算法解决的是如何更省、更快地存储和处理数据的问题,因此,我们就需要一个考量效率和资源消耗的方法,这就是复杂度分析方法。所以,如果你只掌握了数据结构和算法的特点、用法,但是没有学会复杂度分析,那就相当于只知道操作口诀,而没掌握心法。只有把心法了然于胸,才能做到无招胜有招! 所以,复杂度分析这个内容,你也一定要花大力气来啃,必须要拿下,并且要搞得非常熟练。否则,后面的数据结构和算法也很难学好。 搞定复杂度分析,下面就要进入数据结构与算法的正文内容了。 为了让你对数据结构和算法能有个全面的认识,我画了一张图,里面几乎涵盖了所有数据结构和算法书籍中都会讲到的知识点。 但是,作为初学者,或者一个非算法工程师来说,你并不需要掌握图里面的所有知识点。很多高级的数据结构与算法,比如二分图、最大流等,这些在我们平常的开发中很少会用到。所以,你暂时可以不用看。我还是那句话,咱们学习要学会找重点。如果不分重点地学习,眉毛胡子一把抓,学起来肯定会比较吃力。 所以,结合我自己的学习心得,还有这些年的面试、开发经验,我总结了20个最常用的、最基础数据结构与算法,不管是应付面试还是工作需要,只要集中精力逐一攻克这20个知识点就足够了。 这里面有10个数据结构:数组、链表、栈、队列、散列表、二叉树、堆、跳表、图、Trie树;10个算法:递归、排序、二分查找、搜索、哈希算法、贪心算法、分治算法、回溯算法、动态规划、字符串匹配算法。 掌握了这些基础的数据结构和算法,再学更加复杂的数据结构和算法,就会非常容易、非常快。 与此同时,为了帮助大家学习算法,准备了一份学习资料,获取方式:关注我的公众号“程序媛不是程序猿”,回复“算法”即可弹出领取地址。对于新手来说很适用。 在学习数据结构和算法的过程中,你也要注意,不要只是死记硬背,不要为了学习而学习,而是要学习它的“来历”“自身的特点”“适合解决的问题”以及“实际的应用场景”。对于每一种数据结构或算法,我都会从这几个方面进行详细讲解。只要你掌握了《数据结构与算法之美》每节课里讲的内容,就能在开发中灵活应用。 学习数据结构和算法的过程,是非常好的思维训练的过程,所以,千万不要被动地记忆,要多辩证地思考,多问为什么。如果你一直这么坚持做,你会发现,等你学完之后,写代码的时候就会不由自主地考虑到很多性能方面的事情,时间复杂度、空间复杂度非常高的垃圾代码出现的次数就会越来越少。你的编程内功就真正得到了修炼。 一些可以让你事半功倍的学习技巧 前面我给你划了学习的重点,作为一个过来人,现在我就给你分享一下,学习的一些技巧。掌握了这些技巧,可以让你化被动为主动,学起来更加轻松,更加有动力! 边学边练,适度刷题 “边学边练”这一招非常有用。建议你每周花1~2个小时的时间,集中把这周的三节内容涉及的数据结构和算法,全都自己写出来,用代码实现一遍。这样一定会比单纯地看或者听的效果要好很多! 有面试需求的同学,可能会问了,那我还要不要去刷题呢? 我个人的观点是可以“适度”刷题,但一定不要浪费太多时间在刷题上。我们学习的目的还是掌握,然后应用。除非你要面试Google、Facebook这样的公司,它们的算法题目非常非常难,必须大量刷题,才能在短期内提升应试正确率。如果是应对国内公司的技术面试,即便是BAT这样的公司,你只要彻底掌握这个专栏的内容,就足以应对。 多问、多思考、多互动 学习最好的方法是,找到几个人一起学习,一块儿讨论切磋,有问题及时寻求老师答疑。但是,离开大学之后,既没有同学也没有老师,这个条件就比较难具备了。 打怪升级学习法 学习的过程中,我们碰到最大的问题就是,坚持不下来。是的,很多基础课程学起来都非常枯燥。为此,我自己总结了一套“打怪升级学习法”。 游戏你肯定玩过吧?为什么很多看起来非常简单又没有乐趣的游戏,你会玩得不亦乐乎呢?这是因为,当你努力打到一定级别之后,每天看着自己的经验值、战斗力在慢慢提高,那种每天都在一点一点成长的成就感就不由自主地产生了。 知识需要沉淀,不要想试图一下子掌握所有 在学习的过程中,一定会碰到“拦路虎”。如果哪个知识点没有怎么学懂,不要着急,这是正常的。因为,想听一遍、看一遍就把所有知识掌握,这肯定是不可能的。学习知识的过程是反复迭代、不断沉淀的过程。 这些内容是我根据平时的学习和工作、面试经验积累,精心筛选出来的。只要掌握这些内容,应付日常的面试、工作,基本不会有问题。 以上内容出自近70000+程序员的算法课堂《数据结构与算法之美》,这个专栏是市面上唯一一门真正适用于工程师的专栏,专栏中列举大量实际软件开发中的场景,给你展示如何利用数据结构和算法解决真实的问题。整个专栏会涵盖100 多个算法真实项目场景案例,更难得的是它跟市面上晦涩的算法书籍不同的是,还手绘了一些清晰易懂的详解图(总共有 300 多张)。 手绘图—出自《数据结构与算法之美》 专栏已经更新完毕,72 篇文章,27 万字,这个专栏作者并非只是单纯地把某个知识点讲清楚,而是结合作者的理解、实践和经验来讲解,我相信它是一个跟所有国内、国外经典书籍都不一样的专栏,一个可以长期影响一些人的专栏。 这个专栏不会像《算法导论》那样,里面有非常复杂的数学证明和推理。作者会由浅入深,从概念到应用,一点一点给你解释清楚。你只要有高中数学水平,就完全可以学习。 当然,当然希望你最好有些编程基础,如果有项目经验就更好了。这样给你讲数据结构和算法如何提高效率、如何节省存储空间,你就会有很直观的感受。因为,对于每个概念和实现过程,作者都会从实际场景出发,不仅教你“是什么”,还会教你“为什么”,并且告诉你遇到同类型问题应该“怎么做”。 强烈推荐这个专栏给想攻克算法的同学,它改变了无数对算法恐惧的同学,我整理了一些专栏的评价给大家参考。

游客arp6khj2dsufi 2019-12-02 03:09:08 0 浏览量 回答数 0

问题

Go-SDK之如何实现管理文件?

青衫无名 2019-12-01 21:47:06 1303 浏览量 回答数 0
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 企业信息查询 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 2020阿里巴巴研发效能峰会 企业建站模板 云效成长地图 高端建站