1678337820
Cómo convertir una matriz a un objeto JSON en JavaScript
Tutorial de JavaScript | Convertir matriz en objeto JSON
En este tutorial de JavaScript Array, aprenderá a: Convertir Array en objeto JSON JavaScript; Convertir un objeto en una matriz; Convierta matrices bidimensionales (2d) en JSON Object JavaScript
¿Qué es JSON?
JSON significa notación de objetos de JavaScript. JSON es un formato de intercambio de datos extremadamente ligero para el intercambio de datos entre el lado del servidor y el lado del cliente que es rápido y fácil de analizar y generar.
1. Convertir matriz en objeto JSON JavaScript
Puede usar JSON.stringify para convertir una matriz en una cadena con formato JSON en JavaScript.
Supongamos que hay una matriz como "[6, 7, 8, 9]". Si desea convertir esta matriz a JSON Object en javascript. Veamos el ejemplo a continuación.
Ex:
var arr = [5, 6, 7, 8];
var arrayToString = JSON.stringify(Object.assign({}, arr)); // convert array to string
var stringToJsonObject = JSON.parse(arrayToString); // convert string to json object
console.log(stringToJsonObject);
Producción :
{
"0": 5,
"1": 6,
"2": 7,
"2": 8
}
Aquí,
- 1. El método JSON.stringify() y Object.assign() convierte una matriz en una cadena JSON.
- 2. El método JSON.parse() convierte una cadena en un objeto JSON en javascript.
2. Convertir un objeto en una matriz
Al convertir un objeto en una matriz, usaremos el .entries() método de la Object clase. Esto convertirá nuestro objeto en una matriz de matrices. Cada matriz anidada es una lista de dos valores donde el primer elemento es la clave y el segundo elemento es el valor.
Ex:
const obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0};
console.log(Object.entries(obj));
3. Convierta arreglos bidimensionales (2d) a JSON Object JavaScript
Supongamos que hay una matriz como
var arr = [
["Status", "Name", "Marks", "Position"],
["active", "Akash", 10.0, "Web Developer"],
["active", "Vikash", 10.0, "Front-end-dev"],
["deactive", "Manish", 10.0, "designer"],
["active", "Kapil", 10.0, "JavaScript developer"],
["active", "Manoj", 10.0, "Angular developer"],
];
Si desea convertir esta matriz a JSON Object en javascript. Veamos el ejemplo a continuación:
Ex:
//array.
var arr = [
["Status", "Name", "Marks", "Position"],
["active", "Akash", 10.0, "Web Developer"],
["active", "Vikash", 10.0, "Front-end-dev"],
["deactive", "Manish", 10.0, "designer"],
["active", "Kapil", 10.0, "JavaScript developer"],
["active", "Manoj", 10.0, "Angular developer"],
];
//javascript create JSON object from two dimensional Array
function arrayToJSONObject (arr){
//header
var keys = arr[0];
//vacate keys from main array
var newArr = arr.slice(1, arr.length);
var formatted = [],
data = newArr,
cols = keys,
l = cols.length;
for (var i=0; i<data.length; i++) {
var d = data[i],
o = {};
for (var j=0; j<l; j++)
o[cols[j]] = d[j];
formatted.push(o);
}
return formatted;
}
#javascript
What is GEEK
Buddha Community
1678337820
Cómo convertir una matriz a un objeto JSON en JavaScript
Tutorial de JavaScript | Convertir matriz en objeto JSON
En este tutorial de JavaScript Array, aprenderá a: Convertir Array en objeto JSON JavaScript; Convertir un objeto en una matriz; Convierta matrices bidimensionales (2d) en JSON Object JavaScript
¿Qué es JSON?
JSON significa notación de objetos de JavaScript. JSON es un formato de intercambio de datos extremadamente ligero para el intercambio de datos entre el lado del servidor y el lado del cliente que es rápido y fácil de analizar y generar.
1. Convertir matriz en objeto JSON JavaScript
Puede usar JSON.stringify para convertir una matriz en una cadena con formato JSON en JavaScript.
Supongamos que hay una matriz como "[6, 7, 8, 9]". Si desea convertir esta matriz a JSON Object en javascript. Veamos el ejemplo a continuación.
Ex:
var arr = [5, 6, 7, 8];
var arrayToString = JSON.stringify(Object.assign({}, arr)); // convert array to string
var stringToJsonObject = JSON.parse(arrayToString); // convert string to json object
console.log(stringToJsonObject);
Producción :
{
"0": 5,
"1": 6,
"2": 7,
"2": 8
}
Aquí,
- 1. El método JSON.stringify() y Object.assign() convierte una matriz en una cadena JSON.
- 2. El método JSON.parse() convierte una cadena en un objeto JSON en javascript.
2. Convertir un objeto en una matriz
Al convertir un objeto en una matriz, usaremos el .entries() método de la Object clase. Esto convertirá nuestro objeto en una matriz de matrices. Cada matriz anidada es una lista de dos valores donde el primer elemento es la clave y el segundo elemento es el valor.
Ex:
const obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0};
console.log(Object.entries(obj));
3. Convierta arreglos bidimensionales (2d) a JSON Object JavaScript
Supongamos que hay una matriz como
var arr = [
["Status", "Name", "Marks", "Position"],
["active", "Akash", 10.0, "Web Developer"],
["active", "Vikash", 10.0, "Front-end-dev"],
["deactive", "Manish", 10.0, "designer"],
["active", "Kapil", 10.0, "JavaScript developer"],
["active", "Manoj", 10.0, "Angular developer"],
];
Si desea convertir esta matriz a JSON Object en javascript. Veamos el ejemplo a continuación:
Ex:
//array.
var arr = [
["Status", "Name", "Marks", "Position"],
["active", "Akash", 10.0, "Web Developer"],
["active", "Vikash", 10.0, "Front-end-dev"],
["deactive", "Manish", 10.0, "designer"],
["active", "Kapil", 10.0, "JavaScript developer"],
["active", "Manoj", 10.0, "Angular developer"],
];
//javascript create JSON object from two dimensional Array
function arrayToJSONObject (arr){
//header
var keys = arr[0];
//vacate keys from main array
var newArr = arr.slice(1, arr.length);
var formatted = [],
data = newArr,
cols = keys,
l = cols.length;
for (var i=0; i<data.length; i++) {
var d = data[i],
o = {};
for (var j=0; j<l; j++)
o[cols[j]] = d[j];
formatted.push(o);
}
return formatted;
}
#javascript
1625637060
What is JSON? | JSON Objects and JSON Arrays | Working with JSONs Tutorial
In this video, we work with JSONs, which are a common data format for most web services (i.e. APIs). Thank you for watching and happy coding!
Need some new tech gadgets or a new charger? Buy from my Amazon Storefront https://www.amazon.com/shop/blondiebytes
What is an API?
https://youtu.be/T74OdSCBJfw
JSON Google Extension
https://chrome.google.com/webstore/detail/json-formatter/bcjindcccaagfpapjjmafapmmgkkhgoa?hl=en
Endpoint Example
http://maps.googleapis.com/maps/api/geocode/json?address=13+East+60th+Street+New+York,+NY
Check out my courses on LinkedIn Learning!
REFERRAL CODE: https://linkedin-learning.pxf.io/blondiebytes
https://www.linkedin.com/learning/instructors/kathryn-hodge
Support me on Patreon!
https://www.patreon.com/blondiebytes
Check out my Python Basics course on Highbrow!
https://gohighbrow.com/portfolio/python-basics/
Check out behind-the-scenes and more tech tips on my Instagram!
https://instagram.com/blondiebytes/
Free HACKATHON MODE playlist:
https://open.spotify.com/user/12124758083/playlist/6cuse5033woPHT2wf9NdDa?si=VFe9mYuGSP6SUoj8JBYuwg
MY FAVORITE THINGS:
Stitch Fix Invite Code: https://www.stitchfix.com/referral/10013108?sod=w&som=c
FabFitFun Invite Code: http://xo.fff.me/h9-GH
Uber Invite Code: kathrynh1277ue
Postmates Invite Code: 7373F
SoulCycle Invite Code: https://www.soul-cycle.com/r/WY3DlxF0/
Rent The Runway: https://rtr.app.link/e/rfHlXRUZuO
Want to BINGE?? Check out these playlists…
Quick Code Tutorials: https://www.youtube.com/watch?v=4K4QhIAfGKY&index=1&list=PLcLMSci1ZoPu9ryGJvDDuunVMjwKhDpkB
Command Line: https://www.youtube.com/watch?v=Jm8-UFf8IMg&index=1&list=PLcLMSci1ZoPvbvAIn_tuSzMgF1c7VVJ6e
30 Days of Code: https://www.youtube.com/watch?v=K5WxmFfIWbo&index=2&list=PLcLMSci1ZoPs6jV0O3LBJwChjRon3lE1F
Intermediate Web Dev Tutorials: https://www.youtube.com/watch?v=LFa9fnQGb3g&index=1&list=PLcLMSci1ZoPubx8doMzttR2ROIl4uzQbK
GitHub | https://github.com/blondiebytes
Twitter | https://twitter.com/blondiebytes
LinkedIn | https://www.linkedin.com/in/blondiebytes
#jsons #json arrays #json objects #what is json #jsons tutorial #blondiebytes
1659515700
Cómo Recorrer Una Respuesta JSON En JavaScript
Al obtener datos de un servidor remoto, la respuesta del servidor a menudo estará en formato JSON. En este consejo rápido, demostraré cómo puede usar JavaScript para analizar la respuesta del servidor, a fin de acceder a los datos que necesita.
Este proceso generalmente constará de dos pasos: decodificar los datos en una estructura nativa (como una matriz o un objeto), luego usar uno de los métodos incorporados de JavaScript para recorrer esa estructura de datos. En este artículo, cubriré ambos pasos, usando muchos ejemplos ejecutables.
¿Qué es JSON?
Antes de ver cómo lidiar con JSON, tomemos un segundo para entender qué es (y qué no es).
JSON son las siglas de J ava Script O bject N otation . Es un formato basado en texto, independiente del idioma, que se usa comúnmente para transmitir datos en aplicaciones web. JSON se inspiró en la notación literal de objetos de JavaScript, pero existen diferencias entre los dos. Por ejemplo, en JSON, las claves se deben citar con comillas dobles, mientras que en los objetos literales, este no es el caso.
Hay dos formas en que los datos se pueden almacenar en JSON:
- una colección de pares de nombre/valor (también conocido como un objeto JSON)
- una lista ordenada de valores (también conocida como una matriz JSON)
Cuando recibe datos de un servidor web, los datos siempre son una cadena, lo que significa que es su trabajo convertirlos en una estructura de datos con la que pueda trabajar.
Si desea obtener más información sobre cómo funciona JSON, visite el sitio web de JSON .
Obtener JSON desde una API remota
En los siguientes ejemplos, usaremos la fantástica API icanhazdadjoke . Como puede leer en su documentación, al realizar una solicitud GET donde Acceptse establece el encabezado application/json, la API devolverá una carga JSON.
Comencemos con un ejemplo simple:
const xhr = new XMLHttpRequest();
xhr.onreadystatechange = () => {
if (xhr.readyState === XMLHttpRequest.DONE) {
console.log(typeof xhr.responseText);
console.log(xhr.responseText);
}
};
xhr.open('GET', 'https://icanhazdadjoke.com/', true);
xhr.setRequestHeader('Accept', 'application/json');
xhr.send(null);
// string
// {"id":"daaUfibh","joke":"Why was the big cat disqualified from the race? Because it was a cheetah.","status":200}
Como podemos ver, el servidor nos devolvió una cadena. Tendremos que analizar esto en un objeto de JavaScript antes de que podamos recorrer sus propiedades. Podemos hacer esto con JSON.parse() :
if (xhr.readyState === XMLHttpRequest.DONE) {
const res = JSON.parse(xhr.responseText);
console.log(res);
};
// Object { id: "fiyPR7wPZDd", joke: "When does a joke become a dad joke? When it becomes apparent.", status: 200 }
Una vez que tenemos nuestra respuesta como un objeto de JavaScript, hay una serie de métodos que podemos usar para recorrerla.
usar un for...inbucle
Un bucle for…in itera sobre todas las propiedades enumerables de un objeto:
const res = JSON.parse(xhr.responseText);
for (const key in res){
if(obj.hasOwnProperty(key)){
console.log(`${key} : ${res[key]}`)
}
}
// id : H6Elb2LBdxc
// joke : What's blue and not very heavy? Light blue.
// status : 200
Tenga en cuenta que for...oflos bucles se repetirán en toda la cadena de prototipos, por lo que aquí lo estamos usando hasOwnPropertypara asegurarnos de que la propiedad pertenezca a nuestro resobjeto.
Usar Object.entries, Object.valuesoObject.entries
Un enfoque alternativo al anterior es usar uno de Object.keys() , Object.values() u Object.entries() . Estos devolverán una matriz que luego podemos iterar.
Echemos un vistazo al uso de Object.entries. Esto devuelve una matriz de los pares clave/valor del objeto que le pasamos:
const res = JSON.parse(xhr.responseText);
Object.entries(res).forEach((entry) => {
const [key, value] = entry;
console.log(`${key}: ${value}`);
});
// id: SvzIBAQS0Dd
// joke: What did the pirate say on his 80th birthday? Aye Matey!
// status: 200
Tenga en cuenta que la const [key, value] = entry;sintaxis es un ejemplo de desestructuración de matrices que se introdujo en el lenguaje en ES2015.
Esto es mucho más conciso, evita el problema del prototipo mencionado anteriormente y es mi método preferido para recorrer una respuesta JSON.
Uso de la API de búsqueda
Si bien el método anterior que usa el XMLHttpRequestobjeto funciona bien, puede volverse difícil de manejar con bastante rapidez. Podemos hacerlo mejor.
Fetch API es una API basada en Promise, que permite una sintaxis más clara y concisa y lo ayuda a evitar el infierno de la devolución de llamadas. Proporciona un fetch()método definido en el windowobjeto, que puede utilizar para realizar solicitudes. Este método devuelve una Promesa que puede usar para recuperar la respuesta de la solicitud.
Reescribamos nuestro ejemplo anterior para usarlo:
(async () => {
const res = await fetch('https://icanhazdadjoke.com/', {
headers: { Accept: 'application/json' },
});
const json = await res.json();
Object.entries(json).forEach(([key, value]) => {
console.log(`${key}: ${value}`);
});
})();
// id: 2wkykjyIYDd
// joke: What did the traffic light say to the car as it passed? "Don't look I'm changing!"
// status: 200
La API Fetch devuelve un flujo de respuesta . Esto no es JSON, por lo que en lugar de intentar llamarlo JSON.parse(), necesitaremos usar su función response.json() . Esto devuelve una Promesa que se resuelve con el resultado de analizar el texto del cuerpo de la respuesta como JSON.
Tratando con una matriz
Como se mencionó en la parte superior del artículo, una lista ordenada de valores (también conocida como matriz) es JSON válido, así que antes de terminar, examinemos cómo lidiar con esa respuesta.
Para el ejemplo final, usaremos la API REST de GitHub para obtener una lista de los repositorios de un usuario:
(async () => {
async function getRepos(username) {
const url = `https://api.github.com/users/${username}/repos`;
const response = await fetch(url);
const repositories = await response.json();
return repositories;
}
const repos = await getRepos('jameshibbard');
console.log(repos);
})();
// Array(30) [ {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, … ]
Como puede ver, la API ha devuelto una matriz de objetos. Para acceder a cada uno de los objetos individuales, podemos usar un forEachmétodo regular:
repos.forEach((repo) => {
console.log(`{$repo.name} has ${repo.stargazers_count} stars`);
});
// Advanced-React has 0 stars
// angular2-education has 0 stars
// aurelia-reddit-client has 3 stars
// authentication-with-devise-and-cancancan has 20 stars
// ...Alternativamente, por supuesto, puede usar cualquiera de los métodos discutidos anteriormente para recorrer todas las propiedades del objeto y registrarlas en la consola:
repos.forEach((repo) => {
Object.entries(repo).forEach(([key, value]) => {
console.log(`${key}: ${value}`);
});
});
// name: Advanced-React
// full_name: jameshibbard/Advanced-React
// private: false
// ...Conclusión
En este consejo rápido, hemos visto qué es JSON. He demostrado cómo analizar una respuesta JSON de un servidor en una estructura de datos nativa (como una matriz o un objeto) y cómo recorrer dicha estructura para acceder a los datos que contiene.
Fuente: https://www.sitepoint.com/loop-through-json-response-javascript/
1652926080
Cómo Construir Un Analizador En Rust Por Diversión Y Ganancias
Un viernes por la mañana, holgazaneando, estás pensando en los nuevos programas de Netflix para ver. Su jefe viene y le pide que escriba un analizador para un archivo de unidad de Systemd .
Lo necesita para el lunes.
Estás nervioso.
La última vez que se le pidió que escribiera un analizador, se metió en la madriguera del conejo de la web, copiando y pegando fórmulas Regex hasta que funcionó™.
Tomas un sorbo de tu té de boba para calmarte. Buscas Systemd en Google y te gusta... no, no es tan simple como pensabas.
Tu buen truco de copiar y pegar expresiones regulares sale volando por la ventana. Las posibilidades de pasar un fin de semana sin interrupciones para atracones de programas se acercan rápidamente null.
#PEG al rescate
No pierdas la esperanza todavía. Permítame presentarle Parse Expression Grammer (PEG) , una manera fácil de familiarizarse con los analizadores y ahorrar su valioso fin de semana.
PEG es una forma legible de escribir reglas de sintaxis y es bastante similar a las expresiones regulares, que es diferente de una contraparte de gramática libre de contexto como Backus-Naur Form (BNF) en la que las expresiones deben reducirse a símbolos más pequeños. Lo siento, Noam Chomsky , quizás otros días de trabajo.
Usaré una biblioteca de análisis de Rust PEG llamada Pest , que es bastante impresionante. Si aún no lo has hecho, esperaré mientras instalas Rust .
#Empezando
Comencemos con una gramática simple para analizar una declaración de declaración de variable similar a JavaScript. Comenzaremos pensando en un conjunto de reglas para entradas válidas.
#Una declaración de declaración:
- comienza con una palabra clave
var, seguida de uno o más identificadores. - es insensible al espacio en blanco
- termina con un punto y coma (
;)
#Un grupo de identificadores:
- está precedido por una
varpalabra clave - está delimitado por comas
- es insensible al espacio en blanco
#Un identificador:
- puede contener cualquier número de dígitos, caracteres y guiones bajos en mayúsculas y minúsculas
- no puede comenzar con un dígito
- no puede contener ningún espacio
Un identificador es un término , lo que significa que es una pieza irrompible del token. También lo son las varpalabras clave y los puntos y comas.
Regresa un poco al lado BNF, usando Extended Backus-Naur Grammar (EBNF) , podrías definir formalmente la gramática anterior de esta manera:
<alpha> := 'a' | 'b' | 'c' | 'd' | 'e' | /* ... */ 'z'
| 'A' | 'B' | 'C' | 'D' | 'E' | /* ... */ 'Z'
<digit> := 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<Decl> := 'var' <Idents> '\n'? ';'
<Idents> := <Ident> ('\n'? ',' <Ident>)*
<Ident> := <alpha>+ (<alpha> | <digit> | '_')*El nombre de la regla en mayúsculas representa un símbolo que no termina (es decir, se puede dividir en términos más pequeños). El nombre en minúscula representa un término.
En aras de la brevedad, omitimos los espacios en blanco implícitos de las reglas. Básicamente, pueden existir uno o más espacios en blanco entre cada símbolo que ve.
¡Vamos a profundizar en ello! Las reglas <alpha>y <digit>se explican por sí mismas, por lo que dejaremos que lo adivines.
<Decl>es la regla más compleja para una instrucción de declaración, que presenta una varpalabra clave, un <Idents>símbolo, una nueva línea opcional y termina con un punto y coma. Básicamente, esta regla dice: "Cualquier entrada de cadena que comience con var, seguida de uno o más espacios, luego una subregla <Idents>, seguida de uno o más espacios y finalmente termine con un solo punto y coma es válida y felizmente la masticaré. "
<Idents>puede ser un solo <Ident>símbolo, seguido de cero o más pares de comas y <Ident>.
Finalmente, un <Ident>debe comenzar con uno o más caracteres, seguido de cero o más caracteres, dígitos o guiones bajos.
#Ok, código por favor
¡Espera, joven Anakin! Cabeza caliente, eres. He aquí que, con la gramática definida, podremos analizar estas declaraciones:
var foo, bar, baz;
var foo_1, baRamYu,baz99;
var foo_x
, baroo
, bazoo
;No, no me olvidé de formatear mi código. ¡Es JS válido, y también es para nuestro analizador! Aquí hay algo que nuestras reglas no soportarán:
var 99Problems¿Alguien quiere adivinar qué está mal aquí? ✋ Deja tu respuesta en el comentario. (psss, si tu respuesta es correcta, te sigo + 3 me gusta en tu publicación 👍)
#Entra el óxido y las plagas
Ok, espero que ya tengas Rust instalado (En tu terminal, intenta escribir which cargoy ver si aparece). Comience creando un nuevo proyecto binario de Rust con
$ cargo new --bin maybe-js; cd maybe-jsDentro de la carpeta del proyecto, abra el Cargo.tomlarchivo y agregue lo siguiente en dependencies, y ejecútelo cargo updatepara instalarlo.
[dependencies]
pest = "2.0"
pest_derive = "2.0"Una vez hecho esto, cdingrese srcy cree un archivo llamado grammar.pesty pegue lo siguiente en él:
alpha = { 'a'..'z' | 'A'..'Z' }
digit = { '0'..'9' }
underscore = { "_" }
newline = _{ "\n" | "\r" }
WHITESPACE = _{ " " }
declaration = { "var" ~ !newline ~ idents ~ newline? ~ ";" }
idents = { ident ~ (newline? ~ "," ~ ident)* }
ident = @{ !digit ~ (alpha | digit | underscore)+ }Ahora bien, si he tenido su atención durante los últimos minutos, no debería ser difícil adivinar lo que está sucediendo aquí. (Oh, ¿no lo he hecho? De todos modos... aquí vamos)
Los cinco primeros son todos términos. Son conjuntos de valores válidos. el | se llama Choice Operator , que es como "o-si no".
first | or_elseAl hacer coincidir una expresión de elección, firstse intenta. Si first coincide con éxito, la expresión completa se realiza correctamente de inmediato. Sin embargo, si firstfalla, or_elsese intenta a continuación.
La newlineregla tiene un peculiar _antes del corchete, que en Pest habla significa "silencioso": simplemente no lo queremos como parte de nuestros tokens analizados, pero de todos modos es parte de una sintaxis válida.
La WHITESPACEregla tiene un lugar especial en Pest. Si lo definió, Pest insertará automáticamente espacios en blanco opcionales implícitos (de acuerdo con la WHITESPACEregla que defina) entre cada símbolo. Nuevamente, _dice que queremos silenciarlo, ya que no queremos toneladas de espacios en blanco como parte de nuestro árbol de sintaxis.
La declarationregla es muy similar a la contraparte de EBNF que aprendimos antes. Las tildes ("~") simplemente significan "y luego". La regla comienza con una palabra clave "var", seguida de cualquier cosa que no sea un salto de línea (el "!" hace lo que hubiera adivinado intuitivamente: negar una regla), seguida de una subregla idents, un salto de línea opcional y finaliza con un punto y coma.
La identsregla es nuevamente similar al ejemplo EBNF. Es un solo ident, seguido de cero o más idents separados por comas.
La identregla es un poco especial. La "@", conocida como Atomic , delante del corchete está ahí para decir: "No quiero que se apliquen espacios en blanco implícitos a esta regla". Seguro que no queremos incluir ningún espacio en nuestro nombre de variable. Además, marcar una regla como atómica de esta manera trata la regla como un término, silenciando las reglas internas de coincidencia. Cualquier regla interna se descarta.
string_lit = { "\"" ~ inner ~ "\"" }
inner = { ASCII_ALPHANUMERIC* }Tenga en cuenta que ASCII_ALPHANUMERICes una regla incorporada conveniente en Pest para cualquier carácter y dígito ASCII.
Si analizamos una cadena "hola" con esta regla, esto generará primero un string_litnodo, que a su vez tiene un innernodo que contiene la cadena "hola", sin comillas.
Agregar un sigilo "@" delante del string_litcorchete:
string_lit = @{ "\"" ~ inner ~ "\"" }
inner = { ASCII_ALPHANUMERIC* }string_litTerminaremos con un nodo plano que contiene ""hola"".
Un sigilo similar "$" conocido como Compound Atomic , protege los espacios en blanco implícitos dentro de la regla. La diferencia es que permite que las reglas de coincidencia internas se analicen normalmente.
La !digitparte evita que la regla avance si comienza con un número. Si no es así, una o más combinaciones de caracteres, números y guiones bajos están bien.
#Pero espera, ¿dónde está el código?
¡Dang, mi inteligente explorador! Pareces arrinconarme en cada movimiento. Sí, eso no era código en absoluto, sino una definición de gramática de Pest. Ahora tenemos que escribir un código de Rust para analizar un texto. Inicie src/main.rsy agregue lo siguiente:
/// You need to do this to use macro
extern crate pest;
#[macro_use]
extern crate pest_derive;
/// 1. Import modules
use std::fs;
use pest::Parser;
use pest::iterators::Pair;
/// 2. Define a "marker" struct and add a path to our grammar file.
#[derive(Parser)]
#[grammar = "grammar.pest"]
struct IdentParser;
/// 3. Print the detail of a current Pair and optional divider
fn print_pair(pair: &Pair<Rule>, hard_divider: bool) {
println!("Rule: {:?}", pair.as_rule());
println!("Span: {:?}", pair.as_span());
println!("Text: {:?}", pair.as_str());
if hard_divider {
println!("{:=>60}", "");
} else {
println!("{:->60}", "");
}
}
fn main() {
/// 4. Parse a sample string input
let pair = IdentParser::parse(Rule::declaration, "var foo1, bar_99, fooBar;")
.expect("unsuccessful parse")
.next().unwrap();
print_pair(&pair, true);
/// 5. Iterate over the "inner" Pairs
for inner_pair in pair.into_inner() {
print_pair(&inner_pair, true);
match inner_pair.as_rule() {
/// 6. If we match an idents rule...
Rule::idents => {
/// 7. Iterate over another inner Pairs
for inner_inner_pair in inner_pair.into_inner() {
match inner_inner_pair.as_rule() {
/// 8. The term ident is the last level
Rule::ident => {
print_pair(&inner_inner_pair, false);
}
_ => unreachable!(),
}
}
}
_ => unreachable!(),
}
}
}Está bien si no entiendes la mayoría de las cosas aquí. Ejecutémoslo cargo runen el directorio de su proyecto y miremos la salida impresa.
Rule: declaration
Span: Span { str: "var foo1, bar_99, fooBar;", start: 0, end: 28 }
Text: "var foo1, bar_99, fooBarBaz;"
============================================================
Rule: idents
Span: Span { str: "foo1, bar_99, fooBar", start: 4, end: 27 }
Text: "foo1, bar_99, fooBarBaz"
============================================================
Rule: ident
Span: Span { str: "foo1", start: 4, end: 8 }
Text: "foo1"
------------------------------------------------------------
Rule: ident
Span: Span { str: "bar_99", start: 10, end: 16 }
Text: "bar_99"
------------------------------------------------------------
Rule: ident
Span: Span { str: "fooBar", start: 18, end: 27 }
Text: "fooBarBaz"
------------------------------------------------------------El concepto más importante aquí es un Pair. Representa un par de tokens coincidentes o, de manera equivalente, el texto distribuido que una regla con nombre coincidió correctamente.
A menudo usamos Pairs para:
Determinar qué regla produjo elPair
Usar el Paircomo materia prima&str
Inspeccionar las sub-reglas internas nombradas que produjeron elPair
let pair = Parser::parse(Rule::enclosed, "(..6472..) and more text")
.unwrap().next().unwrap();
assert_eq!(pair.as_rule(), Rule::enclosed);
assert_eq!(pair.as_str(), "(..6472..)");
let inner_rules = pair.into_inner();
println!("{}", inner_rules); // --> [number(3, 7)]A Pairpuede tener cero, una o más reglas internas. Para máxima flexibilidad, Pair::into_inner()devuelve Pairs, que es un tipo de iterador sobre cada par.
💡
Pair::into_inner()es un idioma muy común cuando se trabaja con Pest. Asegúrate de entender quéPaires a.
#Vamos a analizar Systemd
Ahora es el momento de poner el trabajo. Aquí hay un ejemplo de un archivo de unidad Systemd:
[Unit]
Description=Nginx
After=network-online.target
Wants=network-online.target
[Service]
Type=simple
Environment=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/home/ec2-user/.local/bin
Environment=LD_LIBRARY_PATH=/usr/local/lib
Environment=PKG_CONFIG_PATH=/usr/local/lib/pkgconfig
ExecStart=/usr/local/sbin/nginx-runner.sh
Restart=on-failure
RestartSec=0
KillMode=process
[Install]
WantedBy=multi-user.targetEl archivo está agrupado en secciones, cada una con un nombre entre corchetes. Cada sección contiene cero o más pares de nombre y valor de propiedad, separados por un signo igual "=".
Tratemos de desarrollar un conjunto de reglas. Cree un nuevo proyecto de óxido con cargo new --bin systemd-parser, luego cree un archivo con el nombre src/grammar.pestcon las siguientes reglas:
/// Implicit white spaces are ok.
WHITESPACE = _{ " " }
/// Set of characters permited
char = { ASCII_ALPHANUMERIC | "." | "_" | "/" | "-" }
/// name is one or more chars. Note that white spaces are allowed.
name = { char+ }
// value can be zero or more char, plus = and : for path variables.
value = { (char | "=" | ":" )* }
/// section is a name, enclosed by square brackets.
section = { "[" ~ name ~ "]" }
/// property pair is a name and value, separated by an equal sign.
property = { name ~ "=" ~ value }
/// A Systemd unit file structure
file = {
SOI ~
((section | property)? ~ NEWLINE)* ~
EOI
}En el main.rsarchivo, comience con lo siguiente
extern crate pest;
#[macro_use]
extern crate pest_derive;
use std::fs;
use std::env::current_dir;
use std::collections::HashMap;
use pest::Parser;
#[derive(Parser)]
#[grammar = "grammar.pest"]
struct SystemdParser;
/// Implement a simple AST representation
#[derive(Debug, Clone)]
pub enum SystemdValue {
List(Vec<String>),
Str(String),
}
// ...Como primer paso, después de las importaciones y la configuración iniciales, definimos una SystemdValueenumeración como una representación simple del tipo de datos en un archivo Systemd. SystemdValue::Str(String)capturará un solo valor de propiedad y SystemdValue::List(Vec<String>)capturará varios valores de propiedad con un nombre de clave de propiedad duplicado. Por ejemplo, en el nginx.servicearchivo anterior hay varias Environmentpropiedades.
Aquí está la mainfunción:
fn main() {
// Read and parse the unit file.
let unparsed_file = fs::read_to_string("nginx.service")
.expect("cannot read file");
let file = SystemdParser::parse(Rule::file, &unparsed_file).expect("fail to parse")
.next()
.unwrap();
// Create a fresh HashMap to store the data.
let mut properties: HashMap<String, HashMap<String, SystemdValue>> = HashMap::new();
// These two mutable variables will be used to store
// section name and property key name.
let mut current_section_name = String::new();
let mut current_key_name = String::new();
// Iterate over the file line-by-line.
for line in file.into_inner() {
match line.as_rule() {
Rule::section => {
// Update the current_section_name
let mut inner_rules = line.into_inner();
current_section_name = inner_rules.next().unwrap().as_str().to_string();
}
Rule::property => {
let mut inner_rules = line.into_inner();
// Get a sub map of properties with the current_section_name key, or create new.
let section = properties.entry(current_section_name.clone()).or_default();
// Get the current property name and value.
let name = inner_rules.next().unwrap().as_str().to_string();
let value = inner_rules.next().unwrap().as_str().to_string();
// If the property name already exists...
if name == current_key_name {
// Get the section of the map with the key name, or insert a new SytemdValue::List.
let entry = section.entry(current_key_name.clone()).or_insert(SystemdValue::List(vec![]));
// Push the value onto the inner vector of SystemdValue::List.
if let SystemdValue::List(ent) = entry {
ent.push(value);
}
} else {
// Create a new SystemdValue::List and save it under name key.
let entry = section.entry(name.clone()).or_insert(SystemdValue::List(vec![]));
// Push the current value onto the vector, then set the
// current_key_name to the current name.
if let SystemdValue::List(ent) = entry {
ent.push(value);
}
current_key_name = name;
}
}
Rule::EOI => (),
_ => unreachable!(),
}
}
}Todo esto está bien, pero no usamos SystemdValue::Strninguna parte del código. Para mantener limpio el código, decidimos tratar cada propiedad como HashMap<String, SystemdValue::List(Vec<String>), donde la clave del mapa es la clave de propiedad y el vector String almacena la lista de valores de propiedad. Si no hay valor, el vector está vacío. Si hay un valor, este vector contiene ese único valor, y así sucesivamente.
Para que la API sea un poco más fácil de usar, escribiremos una pequeña función auxiliar para procesar todos los correos electrónicos de un solo valor Systemd::List(Vec<String>)y convertirlos en archivos Systemd::Str(String).
// Iterate over the nested maps, and convert empty and
// single-element `SystemdValue::List<Vec<String>>` to
// `SystemdValue::Str(String)`.
fn pre_process_map(map: &mut HashMap<String, HashMap<String, SystemdValue>>) {
for (_, value) in map.into_iter() {
for (_, v) in value.into_iter() {
if let SystemdValue::List(vs) = v {
if vs.len() == 0 {
let v_ = SystemdValue::Str(String::new());
*v = v_.clone();
} else if vs.len() == 1 {
let v_ = SystemdValue::Str((vs[0]).clone());
*v = v_.clone();
}
}
}
}
}¡Ahora estamos listos para imprimirlo para que el mundo lo vea!
fn main() {
// Our main code
pre_process_map(properties);
println!("{:#?}", properties);
}¡Auge! ¡Felicidades! Acaba de escribir un analizador de archivos Systemd, además de uno mini JS. 🤯 Ahora tendrás algo de tiempo libre para divertirte el viernes por la noche. Con otra tarde, es posible que incluso descubras cómo serializar el archivo de tu unidad Systemd en JSON para impresionar a tu jefe el lunes.
Puede consultar el código del analizador implementado como biblioteca en [este repositorio] (https://github.com/jochasinga/systemd-parser)
Fuente: https://hackernoon.com/how-to-build-a-parser-in-rust-for-fun-and-profit
1622207074
What is JavaScript - Stackfindover - Blog
Who invented JavaScript, how it works, as we have given information about Programming language in our previous article ( What is PHP ), but today we will talk about what is JavaScript, why JavaScript is used The Answers to all such questions and much other information about JavaScript, you are going to get here today. Hope this information will work for you.
Who invented JavaScript?
JavaScript language was invented by Brendan Eich in 1995. JavaScript is inspired by Java Programming Language. The first name of JavaScript was Mocha which was named by Marc Andreessen, Marc Andreessen is the founder of Netscape and in the same year Mocha was renamed LiveScript, and later in December 1995, it was renamed JavaScript which is still in trend.
What is JavaScript?
JavaScript is a client-side scripting language used with HTML (Hypertext Markup Language). JavaScript is an Interpreted / Oriented language called JS in programming language JavaScript code can be run on any normal web browser. To run the code of JavaScript, we have to enable JavaScript of Web Browser. But some web browsers already have JavaScript enabled.
Today almost all websites are using it as web technology, mind is that there is maximum scope in JavaScript in the coming time, so if you want to become a programmer, then you can be very beneficial to learn JavaScript.
JavaScript Hello World Program
In JavaScript, ‘document.write‘ is used to represent a string on a browser.
<script type="text/javascript">
document.write("Hello World!");
</script>
How to comment JavaScript code?
- For single line comment in JavaScript we have to use // (double slashes)
- For multiple line comments we have to use / * – – * /
<script type="text/javascript">
//single line comment
/* document.write("Hello"); */
</script>
Advantages and Disadvantages of JavaScript
#javascript #javascript code #javascript hello world #what is javascript #who invented javascript