精华内容
下载资源
问答
  • 批处理实例

    2011-09-15 11:51:50
    一些批处理实例,包括系统优化,设置等等.....如果你想学习批处理,为些都是学习批处理的好例子!
  • 批处理实例bat

    2017-05-13 00:30:15
    批处理实例bat
  • windows bat 批处理 实例代码 参考学习; windows bat 批处理 实例代码 参考学习
  • DOS批处理实例教程+常用批处理下载DOS批处理实例教程+常用批处理下载DOS批处理实例教程+常用批处理下载DOS批处理实例教程+常用批处理下载DOS批处理实例教程+常用批处理下载DOS批处理实例教程+常用批处理下载DOS...
  • 批处理实例大全

    2013-06-20 16:27:05
    批处理实例,包括“大型&综合性脚本, 格式转换 ,获取路径, 数值计算···” 一些实例
  • 批处理实例代码教程

    2018-01-02 10:59:36
    批处理实例代码教程,内含定时关机,获取ip,最小化运行,全盘查找文件,删除历史记录等
  • DOC常用命令实例,批处理实例 DOC常用命令实例,批处理实例 DOC常用命令实例,批处理实例
  • 批处理教程,含有批处理实例!!可以帮助你解决系统问题!!
  • 删除操作系统常见的默认共享及对主机进行一系列的 加固的批处理实例,可操作比较强,可以使用。
  • DOS批处理实例教程

    2010-12-05 18:24:12
    DOS批处理实例教程,简单实用,适合新手学习
  • flink实例开发-batch批处理实例

    万次阅读 2018-03-10 22:56:00
    batch批处理实例 下面的示例程序将展示flink的不同应用程序从简单的单词计数到图计算。示例代码演示使用Flink的DataSet API。 以下的全部源代码和更多的例子可以在flink源码仓库的flink-examples-batch或者flink-...

    batch批处理实例

    下面的示例程序将展示flink的不同应用程序从简单的单词计数到图计算。示例代码演示使用Flink的DataSet API

    以下的全部源代码和更多的例子可以在flink源码仓库的flink-examples-batch或者flink-examples-streaming模块中看到。

     

    • 运行一个示例
    • Word Count 单词计数
    • Page Rank 网页排名
    • Connected Componexts 连通分支
    • Relational Query 关系查询

     

    运行一个示例

    为了运行flink程序,我们假设你已经有一个可以运行的flink集群。在快速开始和实例开发模块中详细描述了如何启动flink。

    最简单的方法是运行 ./bin/start-local.sh 脚本。这将启动一个本地的JobManager。

    flink的每一个二进制发布包都包含一个examples目录,里面包含了这个页面的所有例子对应的jar包。

    运行wordCount程序,执行以下命令:

    ./bin/flink run ./examples/batch/WordCount.jar

    其它例子可以以类型的方式执行。

    注意很多例子运行的时候不需要传递任何参数,因为使用的是内置的数据。使用wordCount运行真实数据,你必须通过路径指定具体的数据

    ./bin/flink run ./examples/batch/WordCount.jar --input /path/to/some/text/data --output /path/to/result

    注意,非本地文件系统的话需要模式前缀,例如:hdfs://

     

    Word Count 单词计数

    WordCount是大数据系统中的"hello world"入门程序。它计算单词在文本集合中的频率。

    该算法有两步骤:首先,该文本被切割成单词,然后,这些单词被分组和求和。

    java代码:

    ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
    
    DataSet<String> text = env.readTextFile("/path/to/file");
    
    DataSet<Tuple2<String, Integer>> counts =
            // split up the lines in pairs (2-tuples) containing: (word,1)
            text.flatMap(new Tokenizer())
            // group by the tuple field "0" and sum up tuple field "1"
            .groupBy(0)
            .sum(1);
    
    counts.writeAsCsv(outputPath, "\n", " ");
    
    // User-defined functions
    public static class Tokenizer implements FlatMapFunction<String, Tuple2<String, Integer>> {
    
        @Override
        public void flatMap(String value, Collector<Tuple2<String, Integer>> out) {
            // normalize and split the line
            String[] tokens = value.toLowerCase().split("\\W+");
    
            // emit the pairs
            for (String token : tokens) {
                if (token.length() > 0) {
                    out.collect(new Tuple2<String, Integer>(token, 1));
                }   
            }
        }
    }

    scala代码:

    val env = ExecutionEnvironment.getExecutionEnvironment
    
    // get input data
    val text = env.readTextFile("/path/to/file")
    
    val counts = text.flatMap { _.toLowerCase.split("\\W+") filter { _.nonEmpty } }
      .map { (_, 1) }
      .groupBy(0)
      .sum(1)
    
    counts.writeAsCsv(outputPath, "\n", " ")

    此链接中的wordCount example代码实现了输入参数:--input <path> --output <path>, 作为测试数据,任何文件文件都可以。

     

    Page Rank 网页排名

    PageRank算法通过图中定义的链接计算网页重要性,从一个页面到另一个页面。这是一个迭代的图算法,这意味着它需要执行相同的计算。在每个迭代中,每一页分配当前排名给它所有的邻居,并从邻居节点计算其新等级。PageRank算法是由google进行普及的,主要用在计算网页的重要性排名,应用在搜索结果里面。

    在这个简单示例中,PageRank实现批量得带和固定数量的迭代。

    java代码:

    ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
    
    // read the pages and initial ranks by parsing a CSV file
    DataSet<Tuple2<Long, Double>> pagesWithRanks = env.readCsvFile(pagesInputPath)
    						   .types(Long.class, Double.class)
    
    // the links are encoded as an adjacency list: (page-id, Array(neighbor-ids))
    DataSet<Tuple2<Long, Long[]>> pageLinkLists = getLinksDataSet(env);
    
    // set iterative data set
    IterativeDataSet<Tuple2<Long, Double>> iteration = pagesWithRanks.iterate(maxIterations);
    
    DataSet<Tuple2<Long, Double>> newRanks = iteration
            // join pages with outgoing edges and distribute rank
            .join(pageLinkLists).where(0).equalTo(0).flatMap(new JoinVertexWithEdgesMatch())
            // collect and sum ranks
            .groupBy(0).sum(1)
            // apply dampening factor
            .map(new Dampener(DAMPENING_FACTOR, numPages));
    
    DataSet<Tuple2<Long, Double>> finalPageRanks = iteration.closeWith(
            newRanks,
            newRanks.join(iteration).where(0).equalTo(0)
            // termination condition
            .filter(new EpsilonFilter()));
    
    finalPageRanks.writeAsCsv(outputPath, "\n", " ");
    
    // User-defined functions
    
    public static final class JoinVertexWithEdgesMatch
                        implements FlatJoinFunction<Tuple2<Long, Double>, Tuple2<Long, Long[]>,
                                                Tuple2<Long, Double>> {
    
        @Override
        public void join(<Tuple2<Long, Double> page, Tuple2<Long, Long[]> adj,
                            Collector<Tuple2<Long, Double>> out) {
            Long[] neighbors = adj.f1;
            double rank = page.f1;
            double rankToDistribute = rank / ((double) neigbors.length);
    
            for (int i = 0; i < neighbors.length; i++) {
                out.collect(new Tuple2<Long, Double>(neighbors[i], rankToDistribute));
            }
        }
    }
    
    public static final class Dampener implements MapFunction<Tuple2<Long,Double>, Tuple2<Long,Double>> {
        private final double dampening, randomJump;
    
        public Dampener(double dampening, double numVertices) {
            this.dampening = dampening;
            this.randomJump = (1 - dampening) / numVertices;
        }
    
        @Override
        public Tuple2<Long, Double> map(Tuple2<Long, Double> value) {
            value.f1 = (value.f1 * dampening) + randomJump;
            return value;
        }
    }
    
    public static final class EpsilonFilter
                    implements FilterFunction<Tuple2<Tuple2<Long, Double>, Tuple2<Long, Double>>> {
    
        @Override
        public boolean filter(Tuple2<Tuple2<Long, Double>, Tuple2<Long, Double>> value) {
            return Math.abs(value.f0.f1 - value.f1.f1) > EPSILON;
        }
    }

    scala代码:

    // User-defined types
    case class Link(sourceId: Long, targetId: Long)
    case class Page(pageId: Long, rank: Double)
    case class AdjacencyList(sourceId: Long, targetIds: Array[Long])
    
    // set up execution environment
    val env = ExecutionEnvironment.getExecutionEnvironment
    
    // read the pages and initial ranks by parsing a CSV file
    val pages = env.readCsvFile[Page](pagesInputPath)
    
    // the links are encoded as an adjacency list: (page-id, Array(neighbor-ids))
    val links = env.readCsvFile[Link](linksInputPath)
    
    // assign initial ranks to pages
    val pagesWithRanks = pages.map(p => Page(p, 1.0 / numPages))
    
    // build adjacency list from link input
    val adjacencyLists = links
      // initialize lists
      .map(e => AdjacencyList(e.sourceId, Array(e.targetId)))
      // concatenate lists
      .groupBy("sourceId").reduce {
      (l1, l2) => AdjacencyList(l1.sourceId, l1.targetIds ++ l2.targetIds)
      }
    
    // start iteration
    val finalRanks = pagesWithRanks.iterateWithTermination(maxIterations) {
      currentRanks =>
        val newRanks = currentRanks
          // distribute ranks to target pages
          .join(adjacencyLists).where("pageId").equalTo("sourceId") {
            (page, adjacent, out: Collector[Page]) =>
            for (targetId <- adjacent.targetIds) {
              out.collect(Page(targetId, page.rank / adjacent.targetIds.length))
            }
          }
          // collect ranks and sum them up
          .groupBy("pageId").aggregate(SUM, "rank")
          // apply dampening factor
          .map { p =>
            Page(p.pageId, (p.rank * DAMPENING_FACTOR) + ((1 - DAMPENING_FACTOR) / numPages))
          }
    
        // terminate if no rank update was significant
        val termination = currentRanks.join(newRanks).where("pageId").equalTo("pageId") {
          (current, next, out: Collector[Int]) =>
            // check for significant update
            if (math.abs(current.rank - next.rank) > EPSILON) out.collect(1)
        }
    
        (newRanks, termination)
    }
    
    val result = finalRanks
    
    // emit result
    result.writeAsCsv(outputPath, "\n", " ")

    这个PageRank程序实现了上面的例子。它需要以下参数运行:

    --pages <path> --links <path> --output <path> --numPages <n> --iterations <n>

    输入文件必须是纯文本文件,必须格式化为如下格式:

     

    • pages 使用一个long型的id进行表示,通过换行符进行分割。
    1. 例如: "1\n2\n12\n42\n63\n" 表示给了5个pages 1, 2, 12, 42, 和63.
    • links 使用一对page id进行表示,这一对page id通过空格进行分割。Links通过换行符进行分割
    1. 例如:"1 2\n2 12\n1 12\n42 63\n" 表示给了4对 links (1)->(2), (2)->(12), (1)->(12), 和(42)->(63)

    对于这个简单的实现,要求每一页至少有一个输入和输出连接。一个页面可以指向它自己。

     

    Connected Componexts 连通分支

    算法识别部分的连接组件的一个更大的图连接通过分配所有顶点在相同的连接部分组件ID。类似于PageRank,连接组件是一个迭代算法。在每一步,每个顶点传播当前所有相邻组件ID。一个顶点接受邻居的组件ID,如果它小于自己的组件ID

    这个实现使用一个增量迭代:顶点并没有改变他们的组件ID不参与下一步。这收益更好的性能,因为后来的迭代通常只处理一些异常值顶点

    java代码

    // read vertex and edge data
    DataSet<Long> vertices = getVertexDataSet(env);
    DataSet<Tuple2<Long, Long>> edges = getEdgeDataSet(env).flatMap(new UndirectEdge());
    
    // assign the initial component IDs (equal to the vertex ID)
    DataSet<Tuple2<Long, Long>> verticesWithInitialId = vertices.map(new DuplicateValue<Long>());
    
    // open a delta iteration
    DeltaIteration<Tuple2<Long, Long>, Tuple2<Long, Long>> iteration =
            verticesWithInitialId.iterateDelta(verticesWithInitialId, maxIterations, 0);
    
    // apply the step logic:
    DataSet<Tuple2<Long, Long>> changes = iteration.getWorkset()
            // join with the edges
            .join(edges).where(0).equalTo(0).with(new NeighborWithComponentIDJoin())
            // select the minimum neighbor component ID
            .groupBy(0).aggregate(Aggregations.MIN, 1)
            // update if the component ID of the candidate is smaller
            .join(iteration.getSolutionSet()).where(0).equalTo(0)
            .flatMap(new ComponentIdFilter());
    
    // close the delta iteration (delta and new workset are identical)
    DataSet<Tuple2<Long, Long>> result = iteration.closeWith(changes, changes);
    
    // emit result
    result.writeAsCsv(outputPath, "\n", " ");
    
    // User-defined functions
    
    public static final class DuplicateValue<T> implements MapFunction<T, Tuple2<T, T>> {
    
        @Override
        public Tuple2<T, T> map(T vertex) {
            return new Tuple2<T, T>(vertex, vertex);
        }
    }
    
    public static final class UndirectEdge
                        implements FlatMapFunction<Tuple2<Long, Long>, Tuple2<Long, Long>> {
        Tuple2<Long, Long> invertedEdge = new Tuple2<Long, Long>();
    
        @Override
        public void flatMap(Tuple2<Long, Long> edge, Collector<Tuple2<Long, Long>> out) {
            invertedEdge.f0 = edge.f1;
            invertedEdge.f1 = edge.f0;
            out.collect(edge);
            out.collect(invertedEdge);
        }
    }
    
    public static final class NeighborWithComponentIDJoin
                    implements JoinFunction<Tuple2<Long, Long>, Tuple2<Long, Long>, Tuple2<Long, Long>> {
    
        @Override
        public Tuple2<Long, Long> join(Tuple2<Long, Long> vertexWithComponent, Tuple2<Long, Long> edge) {
            return new Tuple2<Long, Long>(edge.f1, vertexWithComponent.f1);
        }
    }
    
    public static final class ComponentIdFilter
                        implements FlatMapFunction<Tuple2<Tuple2<Long, Long>, Tuple2<Long, Long>>,
                                                Tuple2<Long, Long>> {
    
        @Override
        public void flatMap(Tuple2<Tuple2<Long, Long>, Tuple2<Long, Long>> value,
                            Collector<Tuple2<Long, Long>> out) {
            if (value.f0.f1 < value.f1.f1) {
                out.collect(value.f0);
            }
        }
    }

    scala代码

    // set up execution environment
    val env = ExecutionEnvironment.getExecutionEnvironment
    
    // read vertex and edge data
    // assign the initial components (equal to the vertex id)
    val vertices = getVerticesDataSet(env).map { id => (id, id) }
    
    // undirected edges by emitting for each input edge the input edges itself and an inverted
    // version
    val edges = getEdgesDataSet(env).flatMap { edge => Seq(edge, (edge._2, edge._1)) }
    
    // open a delta iteration
    val verticesWithComponents = vertices.iterateDelta(vertices, maxIterations, Array(0)) {
      (s, ws) =>
    
        // apply the step logic: join with the edges
        val allNeighbors = ws.join(edges).where(0).equalTo(0) { (vertex, edge) =>
          (edge._2, vertex._2)
        }
    
        // select the minimum neighbor
        val minNeighbors = allNeighbors.groupBy(0).min(1)
    
        // update if the component of the candidate is smaller
        val updatedComponents = minNeighbors.join(s).where(0).equalTo(0) {
          (newVertex, oldVertex, out: Collector[(Long, Long)]) =>
            if (newVertex._2 < oldVertex._2) out.collect(newVertex)
        }
    
        // delta and new workset are identical
        (updatedComponents, updatedComponents)
    }
    
    verticesWithComponents.writeAsCsv(outputPath, "\n", " ")

    ConnectedComponents程序实现了上面的例子。它需要以下参数运行:

    --vertices <path> --edges <path> --output <path> --iterations <n>

    输入文件必须是纯文本文件,必须格式化为如下格式:

     

    • Vertices(顶点)使用id表示,使用换行符隔开
    1. 例如 "1\n2\n12\n42\n63\n" 表示指定5个顶点 (1), (2), (12), (42), and (63).

     

    • 顶点的边缘表示为两个id,使用空格隔开,边缘由换行符隔开
    1. 例如: "1 2\n2 12\n1 12\n42 63\n" 表示4个无向链接 (1)-(2), (2)-(12), (1)-(12), and (42)-(63).

     

    Relational Query 关系查询

    关系查询的例子假定两个表,一个订单和指定的其他与lineitem tpc - h基准决策支持。tpc - h是一个标准的数据库行业的基准。见下文说明如何生成输入数据

    这个例子实现了下面的SQL查询

    SELECT l_orderkey, o_shippriority, sum(l_extendedprice) as revenue
        FROM orders, lineitem
    WHERE l_orderkey = o_orderkey
        AND o_orderstatus = "F"
        AND YEAR(o_orderdate) > 1993
        AND o_orderpriority LIKE "5%"
    GROUP BY l_orderkey, o_shippriority;

    Flink程序,实现了上面的查询,看起来如下:

    java代码:

    // get orders data set: (orderkey, orderstatus, orderdate, orderpriority, shippriority)
    DataSet<Tuple5<Integer, String, String, String, Integer>> orders = getOrdersDataSet(env);
    // get lineitem data set: (orderkey, extendedprice)
    DataSet<Tuple2<Integer, Double>> lineitems = getLineitemDataSet(env);
    
    // orders filtered by year: (orderkey, custkey)
    DataSet<Tuple2<Integer, Integer>> ordersFilteredByYear =
            // filter orders
            orders.filter(
                new FilterFunction<Tuple5<Integer, String, String, String, Integer>>() {
                    @Override
                    public boolean filter(Tuple5<Integer, String, String, String, Integer> t) {
                        // status filter
                        if(!t.f1.equals(STATUS_FILTER)) {
                            return false;
                        // year filter
                        } else if(Integer.parseInt(t.f2.substring(0, 4)) <= YEAR_FILTER) {
                            return false;
                        // order priority filter
                        } else if(!t.f3.startsWith(OPRIO_FILTER)) {
                            return false;
                        }
                        return true;
                    }
                })
            // project fields out that are no longer required
            .project(0,4).types(Integer.class, Integer.class);
    
    // join orders with lineitems: (orderkey, shippriority, extendedprice)
    DataSet<Tuple3<Integer, Integer, Double>> lineitemsOfOrders =
            ordersFilteredByYear.joinWithHuge(lineitems)
                                .where(0).equalTo(0)
                                .projectFirst(0,1).projectSecond(1)
                                .types(Integer.class, Integer.class, Double.class);
    
    // extendedprice sums: (orderkey, shippriority, sum(extendedprice))
    DataSet<Tuple3<Integer, Integer, Double>> priceSums =
            // group by order and sum extendedprice
            lineitemsOfOrders.groupBy(0,1).aggregate(Aggregations.SUM, 2);
    
    // emit result
    priceSums.writeAsCsv(outputPath);

    这个Relational Query实现了上面的查询。它需要以下参数运行:

    --orders <path> --lineitem <path> --output <path>

    可以生成订单和lineitem文件使用tpc - h基准测试套件的数据生成器工具(DBGEN)。采取以下步骤生成任意大Flink提供程序的输入文件

     

    1. 下载并解压DBGEN
    2. 复制makefile.suite 为 makefile,并且执行以下修改
    DATABASE = DB2
    MACHINE  = LINUX
    WORKLOAD = TPCH
    CC       = gcc
    1. 使用make命令构架DBGEN
    2. 使用dbgen生成lineitem和命令关系,比例因子(s)在生成的数据集1的结果大约1 GB大小。
    ./dbgen -T o -s 1

     

     

     

     

    获取更多大数据资料,视频以及技术交流请加群:

     

     

     

    展开全文
  • dos批处理实例教程

    2009-10-03 02:20:18
    DOS批处理实例教程+常用批处理下载。强烈推荐!!
  • 批处理实例 会对初学者有所帮助 实例解释的比较详细
  • 批处理实例 逃逸字符%的详细解释 逃逸字符% 是批处理总比较难理解的 这个实例可以帮助你更好的理解逃逸字符%
  • Bat批处理实例练习.rar

    2018-01-05 16:57:52
    Bat批处理 练习题 基础 实例 DOS 看一遍就懂了!Bat批处理 练习题 基础 实例 DOS 看一遍就懂了!
  • 批处理实例:文件复制辅助批处理2008年07月25日 星期五 下午 01:47 本批处理实例主要运用了参数的无限传递,即使用shift命令替换参数位置 @echo off&setlocal EnableDelayedExpansion title 公...

    批处理实例:文件复制辅助批处理
    2008年07月25日 星期五 下午 01:47

    本批处理实例主要运用了参数的无限传递,即使用shift命令替换参数位置

    @echo off&setlocal EnableDelayedExpansion
    title 公孙轩辕制作 QQ 327828994 http://hi.aidu.com/huajinghua
    del /f/q %windir%/u.txt >nul 2>nul
    set b=0
    set x=%1
    if not defined x echo 打开错误!关闭该窗口然后请将需要复制的文件拖入图标内!&pause&exit
    echo   目标文件列表:
    :a
    set "a=%~1"
    if not defined a goto lb
    echo %~f1>>%windir%/u.txt
    shift /1
    goto :a
    :lb
    for /f "tokens=*" %%i in (%windir%/u.txt) do (
    set /a b+=1
    echo "%%i"
    )
    echo 共!b!个文件待复制
    set/p "k=请将目标文件夹拖入:"
    for /f "tokens=*" %%i in (%windir%/u.txt) do (
    set mc=%%~nxi
    set "wj=%%i"
    call :jc
    )
    echo 复制完成,按任意键见退出!&pause>nul&exit
    :jc
    if exist "!k!/!mc!" echo 忽略,存在同名文件!&goto :eof
    echo 正在复制!mc!
    copy "!wj!" !k!/
    goto :eof

     

    另外通过这个实例可以做出一个歌曲复制时同步歌词的批处理,请大家自己动手!

    展开全文
  • 批处理学习的好实例 欢迎下载,批处理之家论坛下载_sed.rar
  • 批处理(batch,批处理文件其文件后缀就是.bat),也称为批处理文件、批处理脚本,也就是对某对象进行批量处理。 批处理文件的生成方式:先创建文本文件,将脚本写好,保存,然后将"*.txt"文件的后缀改成".bat" ...

    批处理(batch,批处理文件其文件后缀就是.bat),也称为批处理文件、批处理脚本,也就是对某对象进行批量处理。

    批处理文件的生成方式:先创建文本文件,将脚本写好,保存,然后将"*.txt"文件的后缀改成".bat"

    1. 批量创建文件夹:md [文件名]

    md后面没有加路径就表示默认在当前文件夹下创建.

    要创建的文件夹数量很多的话,可以结合excel使用更方便

     

    注意此处字符代码的格式需要是ANSI,否则在建中文名文件夹时会出现乱码或者是直接创建失败。如:

     需要更改的话,步骤如下:

    展开全文
  • 必需要掌握的八个cmd命令 DOS 概述及入门 Bat批处理命令大全 BAT全集 批处理入门手册(修正版)
  • └─批处理大全 ├─批处理资料 ├─收集的常用批处理 bat 程序 │ ├─其它类 │ ├─系统类 │ └─网络类 └─经典代码 ├─其他 ├─大型&综合性脚本 │ ├─Tel │ ├─XP安全设置补丁批处理 │ ├...
  • 1、实现关键字实例查询 2、编写直接保存批处理可执行文件 3、输入时实现时时模糊查询(忘记命令时时提醒) 4、命令中英文模糊查询(忘记命令通过中文描述搜索找到此命令) 5、开发人员在线支持更新编写联系QQ:...
  • 目录 目的说明与展示: 要点提示 .bat 代码 2021.3.10补充 %%~ti 利用文件 上次修改时间 目的说明与展示: 看番送壁纸真不戳,不过自己截图后文件名字无关联,打算用批处理文件批量更改。 注:此次重命名是 ...

    目录

    目的说明与展示: 

    要点提示

    .bat  代码

    2021.3.10补充

    %%~ti  利用文件上次修改时间

     


    前言:弄完批处理才发现,其实真要批量给文件按一定顺序重命名,直接按 时间/名称/大小 排好全选中然后右键“重命名”就好了。命名完的文件名:“自定义名(排序)”,这样排序方式还多样。

    哎~,那下文也只是批处理简单代码应用,没有多大实用价值。


    目的说明与展示: 

    看番送壁纸真不戳,不过自己截图后文件名字无关联,打算用批处理文件批量更改。

    注:此次重命名是 自定义+序号+后缀,没有用到原有名字(因为此例原名无意义)。

           程序中注释的部分,是有关截取原名,再以此自定义的(文件原名有意义)

     原图:

    处理后:

    要点提示


    •  for 遍历指定文件,取其名  for %%i in (*.png) do ()
    • set /a  定义序号(随循环而变)
    • for循环内用到序号值  需要使用延迟变量 setlocal EnableDelayedExpansion 

     


    .bat  代码

    注:其中REM注释部分,大多是关于截取原文件名的,可删。

    代码不能高亮展示,很烦

     

     REM rename (图片批量rename) 
     REM 说明:
     REM 遍历所有.png 文件,不用截取文件名字
     REM 利用延迟变量n 以此为序号重命名
    
    @echo off
    setlocal EnableDelayedExpansion 
    		REM 设置延迟变量 引用变量值要用 !var!
    set /a n=1
    		REM 命名序号 n
    for %%i in (*.png) do (
     REM set name=%%i 
     REM echo !name! 
     REM set cut1=!name:~0,12!
    		rem 截取 偏移量=0 取12个字符(含空格)
     REM set cut2=!name:~0,18!
     
     REM //echo !name:~m,n!  亦可
     REM echo !cut2!
    		REM 输出截取后的名字核验
    
    REM echo "Queen's Blood(2) !cut2!.mp4"
    		REM 必须加引号
    		
     echo "请问您今天要来点牢饭吗_壁纸!n!"
    		REM 先确定好名字对不对,再重命名
     set /a n=!n!+1
    		REM 序号自增  注意延迟变量
    		
     REM ren "%%i" "!cut2!.mp4"
     REM ren "%%i" "Queen's Blood(2) !cut2!.mp4"
     ren "%%i" "请问您今天要来点牢饭吗_壁纸!n!.png"
    		REM 重命名 注意延迟变量和后缀
    )
    pause

    2021.3.10补充

    %%~ti  利用文件上次修改时间

    说明:for 遍历文件的顺序默认是按文件名称(?)

      如何按时间遍历呢? 网上没搜到答案。。。

    我想的是:利用文件上次修改时间进行一次重命名,再按名称顺序来一次

     总结


    •  截取后的时间不能直接用来重命名(右图报错),需要格式处理(截取相应字符
    • 截取字符代码:name:~n,m   笔记速查:批处理基础知识

     

    @echo;
    @echo off
    setlocal EnableDelayedExpansion 
    		REM 设置延迟变量 引用变量值要用 !var!
    set /a n=1
    		REM 命名序号 n
    for %%i in (*.pdf) do (
    
     set time2=%%~ti
     REM echo !time2!
    		REM 文件上次修改时间
     set time3=!time2:~0,4!.!time2:~5,2!.!time2:~8,2!.!time2:~11,2!.!time2:~-2!
     echo !time3!
    		REM 时间格式处理:2021.03.10.20.09
     set /a n=!n!+1
    		REM 序号自增  注意延迟变量
    
     REM ren "%%i" "!time2!"
    		REM 无法实现
     ren "%%i" "!time3!.pdf"
    )
    pause

     光改成时间命名,下一步重命名还没做

     


     

     

    展开全文
  • 批处理,也称为批处理脚本,英文译为BATCH,批处理文件后缀BAT就取的前三个字母。它的构成没有固定格式,只要遵守以下这条就ok了:每一行可视为一个命令,每个命令里可以含多条子命令,从第一行开始执行,直到最后一...
  • 包括 ECHO 1. 显示或隐藏文件 ECHO 2. 清理系统垃圾 ECHO 3. 注册表解除锁定 ECHO 4. 修复IE浏览器 ECHO 5. 关闭默认共享 ECHO 6. 管理控制MMC ECHO 7. 清除多余启动项 @ECHO off
  • 批处理可以和很多编程语言配合使用,既可以补充编程语言的效果,还可以提高编程效率,批处理同样可以和Python配合使用,而且python不挑剔文件后缀,只要程序中包含正确的python代码都可以用python解释器解释执行!...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,335
精华内容 23,734
关键字:

批处理实例