Olisikohan tästä kyse:
mysql error 1364 Field doesn't have a default values
My table looks like create table try ( name varchar(8), CREATED_BY varchar(40) not null); and then I have a trigger to auto populate the CREATED_BY field create trigger autoPopulateAtInsert BEFOREstackoverflow.com
for (( X=1; X<51; ++X ))
do
mkdir aa$X
let Y=0
for F in *.jpg
do
mv $F aa${X}/
let Y=Y+1
if [[ $Y == 100 ]]
then let Y=0 ; break ; fi
done
doneEikös tuo pitäisi mennä ihan niin että kun määrittelee koko dokumentin kielen <html lang="fi"> ja sitten esimerkiksi kappaleelle <p lang=en"> tms.
Olen itse käyttänyt vain tuota create-react-app skriptiä joka käyttää kai webpackkia.Tässä kun on harjoitellut tuota Reactia, niin on tullut kauhisteltua tuota pakettien määrää ja samalla myös noiden aukkojen.
Mikä lienee paras tapa Reactin käytöön. Kasata itse, käyttää esim Viteä? Onko jotain versiota mitä kannattaisi käyttää tuotannossa?
Toiset ohjeet sanoo että pitäisi joka päivä päivittää uusimpaan paketit, mikä tietenkin onnistuu kun yksin teen. Olisiko siis jossain tiimissä sovittu joku package-lock.json mitä käytetään. Tietenkin olen kuullut kauhutarinoita nyypiöistä niin kuin minä (ja kokeillutkin), jotka tulee projektiin ja pistää päivittäen koko projektin... itsellä ei ole tiimityöstä vielä mitään kokemusta, niin mitä olisi parhaimmat tavat?
Tästä on varmaan keskusteltu webbidevaus-podcastissa, mutta oon vasta jaksossa alle 30
Abauttiarallaa noin. package-lock kulkee repossa mukana. Repossa voi olla myös editori-asetuksiakin, notta kaikilla on formaatit&säännöt samallalailla automaagisesti (yleensä olettaen, että käytetään esim. vscodea). Tiimeissä/projekteissa on kyllä ohjeistukset/dokumentaatiot tehty alkuvaiheessa ja niitä ylläpidetään koko projektin eliniän ajan, että juurikin uudetkin jäsenet pääsee mukaan ilman, että tarvii joka asiaa käydä läpi yhdessä. Yleensä kyllä ainakin omalla kohdalla ollut tapana, että joku ottaa hoitaakseen uuden jäsenen briiffauksen, jossa käydään koodia ja käytäntöjä läpi ja katsotaan kaikki tärkeimmät linkit mm. dokumentaatioon ym yhdessä.
Mielestäni tärkeämpi (eikä "vain") pointti on se, että kun toinen repon ladattuaan pistää
npm install, nii se lataa samat paketit, eikä mahd. tuoreempia. Toki tän voi toteuttaa niinkin, että määrittelee package.jsonissa tarkemmin, mitä tahdotaan. Etuna se, että on kontrollia siihen mitä päivitetään ja kuinka pitkälle (tarpeellista, jos tietää mitä tekee ja miksi, muuten tarpeetonta).
No tuossa meinasin, että jos on tiedossa, että jotain ei voi/saa päivittää esim. minoreita enempää. En tietty tarkoittanut, että sillä tarkalleen ottaen lockia korvais, mut käytännön tasolla. Tällöin kukaan ei edes vahingossa päivitä. Siksi sulkeissa maininta asiasta.
enum IpAddrVersion {
V4(u8, u8, u8, u8),
V6(u16, u16, u16, u16, u16, u16, u16, u16),
}
type IP = IpAddrVersion;
impl IpAddrVersion {
fn is_valid_v6(&self) -> bool {
match self {
Self::V4(_,_,_,_) => false,
Self::V6(..) => true,
}
}
// TODO
fn regex_match_v6() -> bool {false}
fn to_string() {}
fn to_string_compressed() {}
fn from_string(input: &String) -> IpAddrVersion {
let v6_tuple: (u16, u16, u16, u16, u16, u16, u16, u16) = (0,0,0,0,0,0,0,1);
IpAddrVersion::V6(v6_tuple)
}
}
enum IpAddrVersion {
V4([u8; 4]),
V6([u16; 8]),
}
impl IpAddrVersion {
fn is_valid_v6(&self) -> bool {
match self {
Self::V4(..) => false,
Self::V6(..) => true,
}
}
// TODO
fn regex_match_v6() -> bool {false}
fn to_string() {}
fn to_string_compressed() {}
fn from_string(input: &str) -> IpAddrVersion {
let v6_array = [0,0,0,0,0,0,0,1];
IpAddrVersion::V6(v6_array)
}
} fn from_string(input: &String) -> IpAddrVersion {
let v6_tuple: (u16, u16, u16, u16, u16, u16, u16, u16) = (0,0,0,0,0,0,0,1);
IpAddrVersion::V6(v6_tuple.0, v6_tuple.1, v6_tuple.2, v6_tuple.3, v6_tuple.4, v6_tuple.5, v6_tuple.6, v6_tuple.7)
}Kiitos molemmille vastauksista!
use regex::Regex;
use std::{u8, u16};
enum IpAddrVersion {
V4 {mask: u8, addr:[u8; 4]},
V6 {mask: u8, addr:[u16; 8]},
}
type IP = IpAddrVersion;
impl IpAddrVersion {
fn is_valid_v6(&self) -> bool {
match self {
Self::V4{..} => false,
Self::V6{..} => true,
}
}
// TODO
fn regex_match_v6() -> bool {false}
fn to_string(&self) -> String {
match self {
Self::V4{mask, addr} => {
format!("{}.{}.{}.{}/{}", addr[0], addr[1], addr[2], addr[3], mask)
},
Self::V6{mask, addr} => {
let mut ipv6 = String::new();
for block in addr {
ipv6.push_str(&format!("{:x}", block));
ipv6.push_str(":");
}
ipv6.pop();
ipv6.push_str("/");
ipv6.push_str(&mask.to_string());
return ipv6
},
}
}
fn to_string_compressed(&self) -> String {
match self {
Self::V4{mask, addr} => Self::to_string(&Self),
Self::V6{mask, addr} => {
let mut ipv6 = String::new();
let mut null_block_pattern: (usize, usize) = (0,0); // (start, length)
let mut null_block_pattern_record = null_block_pattern;
// find the longest consecutive null pattern
for (i, block) in addr.iter().enumerate() {
if block==0 {
if null_block_pattern.0 + null_block_pattern.1 == i{
null_block_pattern.1 +=1;
} else {
if null_block_pattern.1 > null_block_pattern_record.1 {
null_block_pattern_record = null_block_pattern;
}
null_block_pattern.0 = i;
null_block_pattern.1 = 1;
}
}
}
if null_block_pattern.1 > null_block_pattern_record.1 {
null_block_pattern = null_block_pattern_record;
}
for (i, block) in addr.iter().enumerate() {
if i >= null_block_pattern_record.1
&& i <= null_block_pattern_record.0 + null_block_pattern_record.1 {
continue;
} else if i == null_block_pattern_record.0 + null_block_pattern_record.1 {
ipv6.push_str(":");
} else {
ipv6.push_str(&format!("{:x}", block));
ipv6.push_str(":");
}
}
ipv6.pop();
ipv6.push_str("/");
ipv6.push_str(&mask.to_string());
return ipv6
},
}
}
fn from_string(input: &String) -> IpAddrVersion {
let reg_v4 = Regex::new(r"\.").unwrap();
if reg_v4.is_match(input) {
//println!("Found IPV4 input string!"); // DEBUG
let blocks = input.split('.');
let blocks: Vec<&str> = blocks.collect();
let mut v4_arr: [u8; 4] = [0;4];
if blocks.len()==4 {
for (i, val) in blocks.iter().enumerate() {
let block_u8 = u8::from_str_radix(val, 10);
match block_u8 {
Ok(v) => v4_arr = v,
Err(_) => panic!("Could not interpret {val} as an decimal number!"),
}
}
}
return IpAddrVersion::V4{mask: 0, addr: v4_arr}
}
let blocks = input.split(':');
let blocks: Vec<&str> = blocks.collect();
let mut v6_arr: [u16; 8] = [0;8];
if blocks.len()==8 {
for (i,val) in blocks.iter().enumerate() {
let block_u16 = u16::from_str_radix(val, 16);
match block_u16 {
Ok(v) => v6_arr = v,
Err(_) => panic!("Could not interpret {val} as an hexadecimal number!"),
}
}
}
return IpAddrVersion::V6{mask: 0, addr: v6_arr}
}
}
fn main() {
//let localhost = IpAddrVersion::V4(127, 0, 0, 1);
let localhost_v6 = IP::from_string(&String::from("2001:0:0:0:0:dc00:0:6"));
let localhost_v4 = IP::from_string(&String::from("127.0.0.1"));
println!("{}", localhost_v4.to_string());
println!("{}", localhost_v6.to_string());
//print_ip_addr(&String::from("localhost"), &localhost_v6);
//print_ip_addr(&String::from("localhost"), &localhost_v4); // verify localhost is still in scope!
}
fn print_ip_addr(host_name: &String, ip_addr: &IpAddrVersion) {
println!("Host: {} IP: {}", host_name, match ip_addr {
IP::V6{mask: m, addr: arr} => format!("{:?}/{}", arr, m),
IP::V4{mask: m, addr: [a,b,c,d]} => format!("{}.{}.{}.{}/{}",
a.to_string(), b.to_string(), c.to_string(), d.to_string(), m )
}
);
}
to_string-ongelma ratkeaa varmaan sanomalla yksinkertaisesti self.to_string(). Jälkimmäisestä en osaa sanoa valmista ratkaisua työntämättä koko höskää kääntäjälle ja yrittämällä siitä, mutta block on nyt nähtävästi &u16, kun taas 0 on jokin epämääräinen luku. Saattaisi lähteä toimimaan joko sanomalla *block == 0 tai kenties block == (0 as u16).Rich (BB code):use regex::Regex; use std::{u8, u16}; enum IpAddrVersion { V4 {mask: u8, addr:[u8; 4]}, V6 {mask: u8, addr:[u16; 8]}, } type IP = IpAddrVersion; impl IpAddrVersion { fn is_valid_v6(&self) -> bool { match self { Self::V4{..} => false, Self::V6{..} => true, } } // TODO fn regex_match_v6() -> bool {false} fn to_string(&self) -> String { match self { Self::V4{mask, addr} => { format!("{}.{}.{}.{}/{}", addr[0], addr[1], addr[2], addr[3], mask) }, Self::V6{mask, addr} => { let mut ipv6 = String::new(); for block in addr { ipv6.push_str(&format!("{:x}", block)); ipv6.push_str(":"); } ipv6.pop(); ipv6.push_str("/"); ipv6.push_str(&mask.to_string()); return ipv6 }, } } fn to_string_compressed(&self) -> String { match self { Self::V4{mask, addr} => Self::to_string(&Self), Self::V6{mask, addr} => { let mut ipv6 = String::new(); let mut null_block_pattern: (usize, usize) = (0,0); // (start, length) let mut null_block_pattern_record = null_block_pattern; // find the longest consecutive null pattern for (i, block) in addr.iter().enumerate() { if block==0 { if null_block_pattern.0 + null_block_pattern.1 == i{ null_block_pattern.1 +=1; } else { if null_block_pattern.1 > null_block_pattern_record.1 { null_block_pattern_record = null_block_pattern; } null_block_pattern.0 = i; null_block_pattern.1 = 1; } } } if null_block_pattern.1 > null_block_pattern_record.1 { null_block_pattern = null_block_pattern_record; } for (i, block) in addr.iter().enumerate() { if i >= null_block_pattern_record.1 && i <= null_block_pattern_record.0 + null_block_pattern_record.1 { continue; } else if i == null_block_pattern_record.0 + null_block_pattern_record.1 { ipv6.push_str(":"); } else { ipv6.push_str(&format!("{:x}", block)); ipv6.push_str(":"); } } ipv6.pop(); ipv6.push_str("/"); ipv6.push_str(&mask.to_string()); return ipv6 }, } } fn from_string(input: &String) -> IpAddrVersion { let reg_v4 = Regex::new(r"\.").unwrap(); if reg_v4.is_match(input) { //println!("Found IPV4 input string!"); // DEBUG let blocks = input.split('.'); let blocks: Vec<&str> = blocks.collect(); let mut v4_arr: [u8; 4] = [0;4]; if blocks.len()==4 { for (i, val) in blocks.iter().enumerate() { let block_u8 = u8::from_str_radix(val, 10); match block_u8 { Ok(v) => v4_arr = v, Err(_) => panic!("Could not interpret {val} as an decimal number!"), } } } return IpAddrVersion::V4{mask: 0, addr: v4_arr} } let blocks = input.split(':'); let blocks: Vec<&str> = blocks.collect(); let mut v6_arr: [u16; 8] = [0;8]; if blocks.len()==8 { for (i,val) in blocks.iter().enumerate() { let block_u16 = u16::from_str_radix(val, 16); match block_u16 { Ok(v) => v6_arr = v, Err(_) => panic!("Could not interpret {val} as an hexadecimal number!"), } } } return IpAddrVersion::V6{mask: 0, addr: v6_arr} } } fn main() { //let localhost = IpAddrVersion::V4(127, 0, 0, 1); let localhost_v6 = IP::from_string(&String::from("2001:0:0:0:0:dc00:0:6")); let localhost_v4 = IP::from_string(&String::from("127.0.0.1")); println!("{}", localhost_v4.to_string()); println!("{}", localhost_v6.to_string()); //print_ip_addr(&String::from("localhost"), &localhost_v6); //print_ip_addr(&String::from("localhost"), &localhost_v4); // verify localhost is still in scope! } fn print_ip_addr(host_name: &String, ip_addr: &IpAddrVersion) { println!("Host: {} IP: {}", host_name, match ip_addr { IP::V6{mask: m, addr: arr} => format!("{:?}/{}", arr, m), IP::V4{mask: m, addr: [a,b,c,d]} => format!("{}.{}.{}.{}/{}", a.to_string(), b.to_string(), c.to_string(), d.to_string(), m ) } ); }
Olen jatkanut koodiharjoitustani Rustilla ja taas muutama aika lähtötason ongelma, jotka korostettu oranssilla. Miten tuo self passataan enumin metodilta toiselle? Ja if vertailu tuottaa seuraavan virheen: can't compare `&u16` with `{integer}` - mikä on oikea tapa korjata tämä?
Alkaa olemaan taas pää niin jumissa, ettei aukene itsestään
Tällähän se lähti toimiin, kiitos
interface QueryResultProps {
result: UseQueryResult;
children: React.ReactNode;
}
const QueryResult: React.FC<QueryResultProps> = ({ result, children }) => {
if (result.isLoading)
return <p>Loading...</p>;
if (result.isError)
return <p>{`Error: ${result.error}`}</p>;
if (result.isSuccess)
return <Fragment>{children}</Fragment>;
return null;
};const items = useQuery('items', getItems);
<QueryResult result={items}>
<ul>
{items.data.map((item: Item) => <li>{item.title}</li>)}
</ul>
</QueryResult>import TextBox from './TextBox';
const tmi = require('tmi.js');
const client = new tmi.Client({
channels: [ 'MrSyS0p' ] //Tähän mikä tahansa "aktiivinen" kanava
});
client.connect();
console.clear();
client.on('message', (channel, tags, message, self) => {
// "Alca: Hello, World!"
console.log(`${tags['display-name']}: ${message}`);
});
function Container() {
const text = [
"Viesti1",
"Viesti2",
"Viesti3",
"Viesti4",
"Viesti5"
]
return (
<div className='container'>
{
text.map((item, index) => {
return <TextBox key={index} Msg={item}/>
})
}
</div>
);
}
export default Container;
if (isLoading) return <Loading />
if (error) return <Error error={error} />
if (data.length === 0) <NoResults />const QueryResult: React.FC<QueryResultProps> = ({ result }) => {
if (result.isLoading) return <p>Loading...</p>;
if (result.isError) return <p>{`Error: ${result.error}`}</p>;
return null;
};
// käyttö:
const items = useQuery('items', getItems);
if (!items.isSuccess) return <QueryResult result={items} />
return (
<ul>
{items.data.map((item: Item) => <li>{item.title}</li>)}
</ul>
)Joo, noin react-queryä olen normaalisti käyttänyt, mutta kun lähes samaa toistaa joka näkymässä useampaan kertaan niin tuli mieleen olisiko abstraktimpaa tapaa toteuttaa sama.
const items = useQuery('items', getItems);
<QueryResult query={items} result={(data: Item[]) =>
<ul>
{data.map((item: Item) => <li>{item.title}</li>)}
</ul>
}/>Kuulostaa koulutehtävältä. Itse lähtisin kahdella sisäkkäisellä loopilla missä missä ulompi kasvattaa ympyrän sädettä ja sisempi käy kulman suuruuksia välilä 0-2π. Sitten tarkistaa osuuko piste kolmion sisälle. Tuosta sitten vaan säätää riittävä tarkkuus, useamman samalla etäisyydellä olevan kolmion hallinta ja mukava ohjelmointikieli.
Ei ole koulutehtävä, eikä itseasiassia ongelmana loopit yms. vaan puhdas matematiikka, että miten valitaan pisteelle lähin kolmio.
Ei kyllä voi toimia niin että lasketaan kolmion keskipisteestä etäisyyttä ja valitaan se jolla on lyhin etäisyys. Esim toisessa kolmiossa sivun mitta voi olla vaikka 1000 ja toisessa 10. Kuitenkin 1000 mittainen kolmio voi olla lähempänä.
Mikä tuossa on ongelma? Kyllä tuon etäisyys suoralle -ratkaisun pitäisi toimia. Neliöjuuria ei tosiaan kannata laskea kuin vasta jos on ihan pakko.Tätä minäkin ajattelin, mutta ongelmana taitaa olla tämmöinen, valitaanko kolmio 1 vai 2. Pisteet punaisella ja sinisellä.
Eikö tuossa ole silloin ihan sama kumpi valitaan tai valitaan molemmat, jos etäisyys on tismalleen sama?
