Un breve análisis de algunas API del módulo de ruta en nodo

1. Una primera introducción al módulo de ruta.

El módulo de ruta es un módulo proporcionado oficialmente por Node.js para procesar rutas . Proporciona una serie de métodos y atributos para satisfacer las necesidades de los usuarios en cuanto al procesamiento de rutas.

2. Módulo de ruta API

2.1 path.join()

El método path.join() se utiliza para unir múltiples fragmentos de ruta en una cadena de ruta completa.

El formato de sintaxis es:

...paths(string) La secuencia de fragmentos de ruta es toda la serie de rutas que necesita unir.

Cabe señalar que el valor devuelto es una cadena

//Introduzca el módulo de ruta const path=require("path")
//Escribe la ruta a unir const pathStr=path.join('/a','/b/c','../','./d','e')

console.log(rutaruta)

2.2 path.basename()

Utilice el método path.basename() para obtener la última parte de la ruta. Este método se utiliza a menudo para obtener

el formato de sintaxis

de

• la
• ruta
• .

const fpath='./a/b/c/index.html'

var nombre completo=ruta.nombrebase(fpath)

consola.log(nombre completo)
//Obtiene el nombre del archivo con el sufijo especificado const namepath=path.basename(fpath,'.html')

console.log(ruta de nombre)

2.3 path.extname()

path.extname() se utiliza para obtener la extensión del archivo en la ruta.

El formato es

• ruta es un parámetro requerido, una cadena que representa una ruta.

• Retorno: Devuelve la cadena de extensión obtenida

const ruta=require("ruta")

const fpath='./a/b/c/d/index.html'

const ftext = ruta.extname (fpath)

consola.log(ftext)

3. En la práctica del caso del reloj,

divida el código proporcionado (un archivo tiene html, css y js al mismo tiempo) en tres archivos, a saber, index.html index.css index.js y guárdelos en un

código fuente

3.1 Pasos de implementación

1. Cree dos expresiones regulares para que coincidan con <style> y <script> respectivamente.
2. Utilice el módulo fs para leer el archivo HTML que debe procesarse
3. Personalice el método resolveCSS para escribir el archivo de estilo index.css
4. Personalice el método resolveJS para escribir el archivo de script index.js
5. Personalice el método resolveHTML para escribir el archivo index.html

3.1.1 Paso 1: importe los módulos necesarios y cree la expresión regular

const path=require('path')
constante fs=requerir('fs')

const regStyle=/<estilo>[sS]*</estilo>/

const scriptruler=/<script>[sS]*</script>/
//El archivo a leer fs.readFile(path.join(__dirname,'/static/index.html'),'utf-8',function(err,dateStr){
    si(errar){
        return console.log("Error de lectura")
    }
   resolverCSS(fechaStr)
   resolverHTML(fechaStr)
   resolverJS(fechaStr)
})

3.1.2 Función de método resolveCSS resolveHTML resolveJS personalizada

resolveCSS(htmlStr){
    const r1=regStyle.exec(htmlStr)
    const newcss=r1[0].replace('<estilo>','').replace('</style>','')
    //Escribe el CSS coincidente en el archivo index.css especificado fs.writeFile(path.join(__dirname,'/static/index.css'),newcss,function(err){
        if(err) return console.log("Error de importación"+err.message)
        console.log("ojbk")
    })
}
función resolverJS(htmlStr){
    const r2=scriptruler.exec(htmlStr)
    const newcss=r2[0].replace('<script>','').replace('</script>','')
    //Escribe el CSS coincidente en el archivo index.js especificado fs.writeFile(path.join(__dirname,'/static/index.js'),newcss,function(err){
        if(err) return console.log("Error de importación"+err.message)
        console.log("ojbk")
    })
}
función resolverHTML(htmlStr){
    const nuevohtml=htmlStr
    .replace(regStyle,'<link rel="stylesheet" href="./index.css">')
    .replace(scriptruler,'<script src="./index.js"></script>')
    //Escribe el CSS coincidente en el archivo index.html especificado fs.writeFile(path.join(__dirname,'/static/index2.html'),newhtml,function(err){
        if(err) return console.log("Error de importación"+err.message)
        console.log("ojbk")
    })
}

El resultado final es eliminar el estilo en el archivo especificado

. Sin embargo, dado que el index.html inicial contiene todo el código, la ubicación donde se almacena cuando se divide el estilo sigue siendo la original, por lo que el index.html final. código constante